Contenu | Rechercher | Menus

Annonce

Si vous avez des soucis pour rester connecté, déconnectez-vous puis reconnectez-vous depuis ce lien en cochant la case
Me connecter automatiquement lors de mes prochaines visites.

À propos de l'équipe du forum.

#1 Le 23/04/2017, à 19:11

plouf1221

Erreur expected '=', ',', ';', 'asm' or '__attribute__[RESOLU]

Bonjour,

J'ai deux fichiers, le premier est intarray.c le second est intarray.h.
J'ai plusieurs fois l'erreur : expected '=', ',', ';', 'asm' or '__attribute__' before '{' token
Je ne sais pas ou chercher pour la résoudre et je ne trouve rien dans mon code qui ressemblerai à une erreur évidente.
Le lien ci dessous indique qu'il s'agit d'un point virgule mal placé, https://openclassrooms.com/forum/sujet/ … befo-96302
J'ai vérifier je n'ai rien de semblable dans mon code.

J'ai aussi plusieurs fois l'erreur : declaration for parameter 'intarray_create_random' but no such parameter
Pareil je ne sais pas quoi faire.

Mon fichier intarray.c

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

#include "intarray.h"


// CONSTRUCTEUR INTARRAY
void intarray_create_aux(intarray tab) {
        tab->data = malloc (sizeof (*(tab->data)) * tab->alloc);
        for (int i = 0; i < tab->alloc; i++)
                tab->data[i] = 0;
        if (tab->alloc <= 0) {
                tab->alloc = 4;
                printf("intarray_create_aux : taille allouée 0.");
                printf(" Nous allouons %d\n", tab->alloc);
        }
}

intarray intarray_create (int len) {
        intarray tab = malloc(sizeof(*tab));
        tab->len = len;
        tab->alloc = len;
        intarray_create_aux(tab);
        return tab;
}

intarray empty_intarray_create (int alloc) {
        intarray tab = malloc(sizeof(*tab));
        tab->len = 0;
        tab->alloc = alloc;
        intarray_create_aux(tab);
        return tab;

}

intarray standard_empty_intarray_create(void) {
        return empty_intarray_create(INTARRAY_DEFAULT_ALLOC);
}


// FONCTION INTARRAY
void intarray_resize(intarray tab, int newalloc) {
        int *newdata = malloc (*newdata * newalloc);
        for (int i = 0; i < tab->len; i++)
                newdata[i] = tab->data[i];
        free(tab->data);        // IMPERATIVEMENT ICI !
        tab->data = newdata;
        tab->alloc = newalloc;
}

void ext_intarray_debug (intarray tab) {
        printf ("Tab. alloc %d ; len %d\n", tab->alloc, tab->len);
        intarray_debug(tab);
}

void ext_intarray_set(intarray tab, int index, int value) {
        printf("ajout de la valeur %d dans la case %d\n", value, index);
        if (index < 0) {
                printf("ext_intarray_set : impossible d'écrire en case %d\n", index);
                return;
        }

        if (index < tab->len) {
                tab->data[index] = value;
                ext_intarray_debug(tab);
                return;
        }

        if (index >= tab->alloc) {
                intarray_resize (tab, 1 + 2 * index);
                for (int i = tab->len; i < index; i++)
                        tab->data[i] = 0;
        }

        // COMPLÉMENT
        if (index >= tab->len && index < tab->alloc) {
                for (int i = tab->len; i < index; i++)
                        tab->data[i] = 0;
                tab->data[index] = value;
        }

        if (index >= tab->len)
                tab->len = index + 1;
}


void intarray_add(intarray tab, int value) {
        ext_intarray_set(tab, tab->len, value);
}

int intarray_get_index_of_min_from(intarray t, int n) {
        int min_pos = n;
        for (int i = n; i < t->len; i++) {
                if (t->data[i] < t->data[min_pos])
                        min_pos = i;
        }
}

int intarray_get_min(intarray t) {
        int value_min = t->data[0];
        for (int i = 0; i < t->len; i++) {
                if (t->data[i] < value_min) {
                        value_min = t->data[i];
                }

        }
        return value_min;
}

int intarray_get_max(intarray t) {
        int value_max = t->data[0];
        for (int i = 0; i < t->len; i++) {
                if (t->data[i] > value_max)
                        value_max = t->data[i];
        }
        return value_max;
}


int intarray_get_index_of_min(intarray t) {
        int min_pos = 0;
        for (int i = 0; i < t->len; i++)
                if (t->data[i] < t->data[min_pos])
                        min_pos = i;

        return min_pos;
}

int intarray_get_index_of_max(intarray t) {
        int max_pos = 0;
        for (int i = 0; i < t->len; i++) {
                if (t->data[i] > t->data[max_pos])
                        max_pos = i;
        }
        return max_pos;
}

void intarray_tri_minimum(intarray t) {
        for (int j = 0; j < t->len-1; j++) {

                // RENDRE INDÉPENDANTES LES VARIABLES I ET J D'UNE BOUCLE À UNE AUTRE
                int position = j;

                // Comparaison deux à deux
                for (int i = j+1; i < t->len; i++) {
                        if(t->data[i] < t->data[position])
                                position = i;
                }

                // Permutation
                int tmp = t->data[j];
                t->data[j] = t->data[position];
                t->data[position] = tmp;
        }
}

void intarray_debug (intarray tab) {
        printf ("[ ");
        for (int i = 0; i < tab->len - 1; i++)
                printf ("%d, ", tab->data [i]);
        if (tab->len > 0)
                printf ("%d", tab->data [tab->len - 1]);
        printf (" ]\n");
}

intarray intarray_concate (intarray t1, intarray t2) {
        intarray t = intarray_create (t1->len + t2->len);
        int j = 0;
        for (int i = 0; i < t1->len; i++) {
                t->data[j] = t1->data[i];
                j++;
        }

        for (int i = 0; i < t2->len; i++) {
                t->data[j] = t2->data[i];
                j++;
        }

        return t;
}

void intarray_min (intarray t1) {
        int index = 0;
        for (int i = 1; i < t1->len; i++) {
                if (t1->data[index] > t1->data[i])
                        index = i;
        }

        printf("La valeur min de mon tableau est : %d\n",t1->data[index]);
}

void intarray_print_positive_values (intarray tab) {
        for (int i = 0; i < tab->len; i++)
                if (tab->data [i] >= 0)
                        printf("indice : %d\t valeur : %d\n", i, tab->data [i]);
}

int intarray_search (intarray tab,  int n) {
        bool boolean = false;
        for (int i = 0; i < tab->len; i++)
                if (tab->data [i] == n)
                        boolean = true;
        return boolean;
}

int intarray_nb_occurence (intarray tab, int n) {
        int compteur = 0;
        for (int i = 0; i < tab->len; i++)
                if (tab->data [i] == n)
                        compteur++;
        return compteur;
}

void intarray_destroy (intarray tab) {
        free (tab->data);
        free(tab);
}

int intarray_get (intarray tab, int index) {
        if ( index < 0 || index > tab->len -1 ) {
                printf ("Erreur intarray_get\nL'index %d est invalide\n",index);
                printf ("Les indexs valides sont entre 0 et %d\n", tab->len -1);
                return -1;
        }
        return tab->data [index];
}

void intarray_set (intarray tab, int index, int value) {
        if ( index < 0 || index > tab->len -1 ) {
                printf ("Erreur intarray_set\nL'index %d est invalide\n",index);
                printf ("Les valeurs valides sont entre 0 et %d\n", tab->len -1);
                return;
        }
        tab->data [index] = value;
}

int intarray_length (intarray tab) {
        return tab->len;
}

int intarray_sum (intarray tab) {
        int sum = 0;
        for (int i = 0; i < tab->len; i++)
                sum += tab->data [i];
        if ( tab->len <= 0 ) {
                printf ("intarray_sum tableau de longueur négatif ou null\n");
                return -1;
        }
        return sum;
}

float intarray_average (intarray tab) {
        int sum = intarray_sum (tab);
        if ( tab->len <= 0 ) {
                printf ("intarray_average tableau de longueur négatif ou null\n");
                return -1;
        }
        return (sum + 0.0) / tab->len;
}

intarray intarray_copy (intarray tab) {
        intarray copy = intarray_create(tab->len);
        for (int i = 0; i < tab->len; i++)
                copy->data[i] = tab->data[i];
        return copy;
}

float intarray_median (intarray tab) {
        if ( tab->len <= 0 ) {
                printf ("intarray_sum tableau de longueur négatif ou null");
                return -1;
        }

        float median = 0.0;

        // Copie du tableau pour garder le tableau originale
        intarray copy = intarray_copy (tab);


        // Trie de la copie
        intarray_tri_minimum (copy);

        if (copy->len % 2 != 0)
                median = copy->data[(copy->len - 1) / 2];

        else {
                int v1 = copy->data[(copy->len - 1) / 2];
                int v2 = copy->data[copy->len / 2];
                median = (v1 +v2) / 2.0;
        }

        //intarray_destroy(copy);
        return median;
}

void UNSORTED_intarray_delete(intarray tab, int index) {
        if (index < 0 || index > tab->len) {
                printf("intarray_delete : index invalide %d", index);
                return;
        }
        tab->data[index] = tab->data[tab->len - 1];
        tab->len--;
}

void intarray_delete(intarray tab,  int index) {
        if (index < 0 || index > tab->len) {
                printf("intarray_delete : index invalide %d", index);
                return;
        }

        for (int i = index; i < tab->len - 1; i++)
                tab->data[i] = tab->data[i+1];
        tab->len--;

        /* Changement indice (idem)
           void intarray_delete (intarray *tab-> int index) {
           for (int i = index + 1; i < tab->len; i++)
           tab->data[i-1] = tab->>data[i];
           tab->len--; */
}

mon fichier intarray.h

#ifndef __INTARRAY_H__
#define __INTARRAY_H__

typedef struct _intarray *intarray;         // inarray est un pointeur de struct
typedef struct _intarray S_intarray;

struct _intarray {
    int *data;
    int len;        // Nombre d'éléments
    int alloc;      // Allocation
};

#define INTARRAY_DEFAULT_ALLOC 8

void intarray_resize(intarray tab, int newalloc);

intarray intarray_create(int len);

intarray standart_empty_intarray_create()

intarray empty_intarray_create(int alloc);

intarray standard_empty_intarray_create(void);

void intarray_create_aux(intarray tab);

void intarray_destroy(intarray tab);

int intarray_get(intarray tab, int index);

/* pour les tableaux de taille max fixe seulement */
void intarray_set(intarray tab, int index, int value);

/* comme intarray_set, mais modifie alloc si nécessaire */
void ext_intarray_set(intarray tab, int index, int value);

void intarray_add(intarray tab, int value);
/*
 *   Déplace un seul élément (très rapide).
 *   Attention : modifie l'ordre des éléments de tab.
 *   Si on souhaite que l'ordre reste inchangé,
 *   il faut appeler la fonction intarray_delete. */

void UNSORTED_intarray_delete(intarray tab, int index);
/*
 *   Déplace jusqu'à N éléments (dans le pire des cas),
 *     N étant la taille du tableau. */

void intarray_delete(intarray tab, int index);

int intarray_len(intarray tab);

void intarray_debug(intarray tab);

void ext_intarray_debug(intarray tab);

void intarray_print_positive_values(intarray tab);

int intarray_search(intarray tab, int n);

int intarray_nb_occurences(intarray tab, int n);

void intarray_tri_minimum(intarray tab);

intarray intarray_copy(intarray tab);

int intarray_sum(intarray tab);

float intarray_average(intarray tab);

float intarray_median (intarray tab);

/* retourne le résultat de la concaténation de T1 et T2 */
intarray intarray_concat(intarray T1, intarray T2);

/* retourne la plus petite valeur contenue dans tab */
int intarray_get_min(intarray tab);

/* retourne l'index de la plus petite valeur contenue dans tab */
int intarray_get_index_of_min(intarray tab);

/*
 *    retourne l'index de la plus petite valeur contenur dans tab,
 *    entre la case numéro n et la fin du tableau. */
int intarray_get_index_of_min_from(intarray tab, int n);

/* retourne la plus grande valeur contenue dans tab */
int intarray_get_max(intarray tab);

/* retourne l'index de la plus grande valeur contenue dans tab */
int intarray_get_index_of_max(intarray tab);

/*
 *    retourne l'index de la plus grande valeur contenur dans tab,
 *       entre la case numéro n et la fin du tableau. */
int intarray_get_index_of_max_from(intarray tab, int index);

/* tirage aléatoire d'entiers entre a et b pour créer un tableau de
 * taille n */
intarray intarray_create_random(int n, int a, int b);
#endif

Merci pour votre aide

Dernière modification par plouf1221 (Le 26/04/2017, à 09:53)

Hors ligne

#2 Le 23/04/2017, à 19:52

no_spleen

Re : Erreur expected '=', ',', ';', 'asm' or '__attribute__[RESOLU]

Bonjour,

Il manque un point virgule à la fin de la ligne

intarray standart_empty_intarray_create()

dans intarray.h

Bàt,

Hors ligne

#3 Le 24/04/2017, à 10:55

soshy

Re : Erreur expected '=', ',', ';', 'asm' or '__attribute__[RESOLU]

En fonction de ton editeur, tu dois avoir des plugin pour t'aider a facilement detecter de genre d'erreur. Ca s'appelle des "linter", a mon avis, ca vaut le coup de te renseigner wink

Hors ligne

#4 Le 24/04/2017, à 11:33

plouf1221

Re : Erreur expected '=', ',', ';', 'asm' or '__attribute__[RESOLU]

Merci pour vos conseils. Je vais voir ce week end ou en soirée pas trop chargée. En me promenant sur le site Ubuntu j'ai également entendu parlé de GDB.
Faut que je teste cela également.
Mon éditeur est Vim si vous en connaissez des bons à me conseiller ce serait cool de me les communiquer.
En regardant sur internet j'ai déjà un linter qui s'appelle syntastic https://github.com/vim-syntastic/syntastic
Je vais sûrement en prendre un autre, celui la https://github.com/timheap/linters.vim
J'espère qu'il n'y aura pas de conflit entre les deux.
Il me reste plus qu'une seule erreur : 1 intarray.c|320 col 1 error| expected declaration or statement at end of input $ (syntastic)
Mais je ne vois pas d'erreur dans cette fonction

void intarray_delete(intarray tab,  int index) {
        if (index < 0 || index > tab->len) {
                printf("intarray_delete : index invalide %d", index);
                return;
        }

        for (int i = index; i < tab->len - 1; i++)
                tab->data[i] = tab->data[i+1];
        tab->len--;

        /* Changement indice (idem)
           void intarray_delete (intarray *tab-> int index) {
           for (int i = index + 1; i < tab->len; i++)
           tab->data[i-1] = tab->data[i];
           tab->len--; */
}

Hors ligne

#5 Le 24/04/2017, à 19:15

claudius01

Re : Erreur expected '=', ',', ';', 'asm' or '__attribute__[RESOLU]

Bonsoir,

C'est un test d’assiduité ou quoi ..., sauf erreur de ma part, il manque une accolade fermante '}' (pas besoin d'un éditeur sophistiqué pour le trouver ;-)
(vi le trouve immédiatement ;-))

A suivre...

Hors ligne

#6 Le 24/04/2017, à 20:20

lann

Re : Erreur expected '=', ',', ';', 'asm' or '__attribute__[RESOLU]

éditeur : sans contestation emacs smile

Hors ligne

#7 Le 25/04/2017, à 12:45

plouf1221

Re : Erreur expected '=', ',', ';', 'asm' or '__attribute__[RESOLU]

Je suis désolé mais je ne vois pas ou il manque une accolade.
La fonction à bien sa paire d'accolade.
Le if également.
Le for n'a qu'une seul instruction donc bas besoins.
Et le reste ce sont des commentaires.
Je dois être aveugle, pouvez vous m'éclairer ?

Hors ligne

#8 Le 25/04/2017, à 13:13

soshy

Re : Erreur expected '=', ',', ';', 'asm' or '__attribute__[RESOLU]

Les linters sont pas forcement toujours parfait. J'imagine que c'est l'accolade ouvrante du commentaire qui ne lui va pas. Tu peux essayer de la fermer, supprimer le commentaire ou changer la facon dont il est fait
exemple:

/*
 * le code
 * le code ligne2
 */

ou

// le code
// le code ligne 2

Peut etre que ca lui plaira mieux. Si c'est ca, tu peux faire un bug report j'imagine.

Dernière modification par soshy (Le 25/04/2017, à 13:16)

Hors ligne

#9 Le 25/04/2017, à 19:23

claudius01

Re : Erreur expected '=', ',', ';', 'asm' or '__attribute__[RESOLU]

Bonsoir,

Certes, mais quand je vois les lignes suivantes même en commentaire; à savoir:

...
           void intarray_delete (intarray *tab-> int index) {
           for (int i = index + 1; i < tab->len; i++)
           tab->data[i-1] = tab->data[i];
           tab->len--;
...

Je mets le code à la poubelle car c'est illisible et donc incompréhensible ... heureusement que les indentations ont été inventées ;-)

Dernière modification par claudius01 (Le 25/04/2017, à 19:44)

Hors ligne

#10 Le 25/04/2017, à 20:08

plouf1221

Re : Erreur expected '=', ',', ';', 'asm' or '__attribute__[RESOLU]

Bonsoir,

J'ai supprimé le commentaire j'ai la même erreur.

void intarray_delete(intarray tab,  int index) {
        if (index < 0 || index > tab->len) {
                printf("intarray_delete : index invalide %d", index);
                return;
        }

        for (int i = index; i < tab->len - 1; i++)
                tab->data[i] = tab->data[i+1];
        tab->len--;
}

Même en supprimant toute la fonction intarray_delete(...)
J'ai la même erreur.

Merci déjà pour votre aide.

Dernière modification par plouf1221 (Le 25/04/2017, à 20:17)

Hors ligne

#11 Le 25/04/2017, à 21:16

no_spleen

Re : Erreur expected '=', ',', ';', 'asm' or '__attribute__[RESOLU]

Bonjour,

Ton code tel que donné dans ton premier post, avec le point virgule en +, compile. Donc, j'imagine que ton erreur vient d'un changement que tu as fait par la suite. Il nous faudrait donc la dernière version de ton code.

Tu peux aussi essayer de compiler avec clang, il donne généralement des erreurs plus explicites. Par exemple, il faudra que tu regardes à ceci :

intarray.c:98:1: warning: control reaches end of non-void function

Il s'agit de intarray_get_index_of_min_from.

Bàt,

Hors ligne

#12 Le 26/04/2017, à 09:41

plouf1221

Re : Erreur expected '=', ',', ';', 'asm' or '__attribute__[RESOLU]

Bonjour,

J'ai trouvé la dernière erreur il s'agit bien d'un crochet qui manque dans la fonction intarray_tri_minimum indiquer par GCC.
Merci à tous pour votre aide et votre patience.
Sa fonctionne impeccablement maintenant.

Voici la dernière version de mon code sans la correction :

intarray.c

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

#include "intarray.h"


// CONSTRUCTEUR INTARRAY
void intarray_create_aux(intarray tab) {
        tab->data = malloc ( sizeof (*(tab->data)) * tab->alloc );
        for (int i = 0; i < tab->alloc; i++)
                tab->data[i] = 0;
        if (tab->alloc <= 0) {
                tab->alloc = 4;
                printf("intarray_create_aux : taille allouée 0.");
                printf(" Nous allouons %d\n", tab->alloc);
        }
}

intarray intarray_create(int len) {
        intarray tab = malloc( sizeof(*tab) );
        tab->len = len;
        tab->alloc = len;
        intarray_create_aux(tab);
        return tab;
}

intarray empty_intarray_create(int alloc) {
        intarray tab = malloc( sizeof(*tab) );
        tab->len = 0;
        tab->alloc = alloc;
        intarray_create_aux(tab);
        return tab;

}

intarray standard_empty_intarray_create(void) {
        return empty_intarray_create(INTARRAY_DEFAULT_ALLOC);
}


// FONCTION INTARRAY
void intarray_resize(intarray tab, int newalloc) {
        int *newdata = malloc (*newdata * newalloc);
        for (int i = 0; i < tab->len; i++)
                newdata[i] = tab->data[i];
        free(tab->data);        // IMPERATIVEMENT ICI !
        tab->data = newdata;
        tab->alloc = newalloc;
}

void ext_intarray_debug(intarray tab) {
        printf ("Tab. alloc %d ; len %d\n", tab->alloc, tab->len);
        intarray_debug(tab);
}

void ext_intarray_set(intarray tab, int index, int value) {
        printf("ajout de la valeur %d dans la case %d\n", value, index);
        if (index < 0) {
                printf("ext_intarray_set : impossible d'écrire en case %d\n", index);
                return;
        }

        if (index < tab->len) {
                tab->data[index] = value;
                ext_intarray_debug(tab);
                return;
        }

        if (index >= tab->alloc) {
                intarray_resize (tab, 1 + 2 * index);
                for (int i = tab->len; i < index; i++)
                        tab->data[i] = 0;
        }

        // COMPLÉMENT
        if (index >= tab->len && index < tab->alloc) {
                for (int i = tab->len; i < index; i++)
                        tab->data[i] = 0;
                tab->data[index] = value;
        }

        if (index >= tab->len)
                tab->len = index + 1;
}


void intarray_add(intarray tab, int value) {
        ext_intarray_set(tab, tab->len, value);
}

int intarray_get_index_of_min_from(intarray t, int n) {
        int min_pos = n;
        for (int i = n; i < t->len; i++) {
                if (t->data[i] < t->data[min_pos])
                        min_pos = i;
        }
}

int intarray_get_min(intarray t) {
        int value_min = t->data[0];
        for (int i = 0; i < t->len; i++) {
                if (t->data[i] < value_min) {
                        value_min = t->data[i];
                }

        }
        return value_min;
}

int intarray_get_max(intarray t) {
        int value_max = t->data[0];
        for (int i = 0; i < t->len; i++) {
                if (t->data[i] > value_max)
                        value_max = t->data[i];
        }
        return value_max;
}


int intarray_get_index_of_min(intarray t) {
        int min_pos = 0;
        for (int i = 0; i < t->len; i++)
                if (t->data[i] < t->data[min_pos])
                        min_pos = i;

        return min_pos;
}

int intarray_get_index_of_max(intarray t) {
        int max_pos = 0;
        for (int i = 0; i < t->len; i++) {
                if (t->data[i] > t->data[max_pos])
                        max_pos = i;
        }
        return max_pos;
}

void intarray_tri_minimum(intarray t) {
        for (int j = 0; j < t->len-1; j++) {

                // RENDRE INDÉPENDANTES LES VARIABLES I ET J D'UNE BOUCLE À UNE AUTRE
                int position = j;

                // Comparaison deux à deux
                for (int i = j+1; i < t->len; i++) {
                        if(t->data[i] < t->data[position])
                                position = i;
                }

                // Permutation
                int tmp = t->data[j];
                t->data[j] = t->data[position];
                t->data[position] = tmp;

}

void intarray_debug(intarray tab) {
        printf ("[ ");
        for (int i = 0; i < tab->len - 1; i++)
                printf ("%d, ", tab->data [i]);
        if (tab->len > 0)
                printf ("%d", tab->data [tab->len - 1]);
        printf (" ]\n");
}

intarray intarray_concate(intarray t1, intarray t2) {
        intarray t = intarray_create (t1->len + t2->len);
        int j = 0;
        for (int i = 0; i < t1->len; i++) {
                t->data[j] = t1->data[i];
                j++;
        }

        for (int i = 0; i < t2->len; i++) {
                t->data[j] = t2->data[i];
                j++;
        }

        return t;
}

void intarray_min (intarray t1) {
        int index = 0;
        for (int i = 1; i < t1->len; i++) {
                if (t1->data[index] > t1->data[i])
                        index = i;
        }

        printf("La valeur min de mon tableau est : %d\n",t1->data[index]);
}

void intarray_print_positive_values(intarray tab) {
        for (int i = 0; i < tab->len; i++)
                if (tab->data [i] >= 0)
                        printf("indice : %d\t valeur : %d\n", i, tab->data [i]);
}

int intarray_search(intarray tab,  int n) {
        bool boolean = false;
        for (int i = 0; i < tab->len; i++)
                if (tab->data [i] == n)
                        boolean = true;
        return boolean;
}

int intarray_nb_occurence(intarray tab, int n) {
        int compteur = 0;
        for (int i = 0; i < tab->len; i++)
                if (tab->data [i] == n)
                        compteur++;
        return compteur;
}

void intarray_destroy(intarray tab) {
        free (tab->data);
        free(tab);
}

int intarray_get(intarray tab, int index) {
        if ( index < 0 || index > tab->len -1 ) {
                printf ("Erreur intarray_get\nL'index %d est invalide\n",index);
                printf ("Les indexs valides sont entre 0 et %d\n", tab->len -1);
                return -1;
        }
        return tab->data [index];
}

void intarray_set(intarray tab, int index, int value) {
        if ( index < 0 || index > tab->len -1 ) {
                printf ("Erreur intarray_set\nL'index %d est invalide\n",index);
                printf ("Les valeurs valides sont entre 0 et %d\n", tab->len -1);
                return;
        }
        tab->data [index] = value;
}

int intarray_length(intarray tab) {
        return tab->len;
}

int intarray_sum(intarray tab) {
        int sum = 0;
        for (int i = 0; i < tab->len; i++)
                sum += tab->data [i];
        if ( tab->len <= 0 ) {
                printf ("intarray_sum tableau de longueur négatif ou null\n");
                return -1;
        }
        return sum;
}

float intarray_average(intarray tab) {
        int sum = intarray_sum (tab);
        if ( tab->len <= 0 ) {
                printf ("intarray_average tableau de longueur négatif ou null\n");
                return -1;
        }
        return (sum + 0.0) / tab->len;
}

intarray intarray_copy(intarray tab) {
        intarray copy = intarray_create(tab->len);
        for (int i = 0; i < tab->len; i++)
                copy->data[i] = tab->data[i];
        return copy;
}

float intarray_median(intarray tab) {
        if ( tab->len <= 0 ) {
                printf ("intarray_sum tableau de longueur négatif ou null");
                return -1;
        }

        float median = 0.0;

        // Copie du tableau pour garder le tableau originale
        intarray copy = intarray_copy (tab);


        // Trie de la copie
        intarray_tri_minimum (copy);

        if (copy->len % 2 != 0)
                median = copy->data[(copy->len - 1) / 2];

        else {
                int v1 = copy->data[(copy->len - 1) / 2];
                int v2 = copy->data[copy->len / 2];
                median = (v1 +v2) / 2.0;
        }

        //intarray_destroy(copy);
        return median;
}

void UNSORTED_intarray_delete(intarray tab, int index) {
        if (index < 0 || index > tab->len) {
                printf("intarray_delete : index invalide %d", index);
                return;
        }
        tab->data[index] = tab->data[tab->len - 1];
        tab->len--;
}

void intarray_delete(intarray tab,  int index) {
        if (index < 0 || index > tab->len) {
                printf("intarray_delete : index invalide %d", index);
                return;
        }

        for (int i = index; i < tab->len - 1; i++)
                tab->data[i] = tab->data[i+1];
        tab->len--;
}

intarray.h

#ifndef __INTARRAY_H__
#define __INTARRAY_H__

typedef struct _intarray *intarray;         // inarray est un pointeur de struct
typedef struct _intarray S_intarray;

struct _intarray {
    int *data;
    int len;        // Nombre d'éléments
    int alloc;      // Allocation
};

#define INTARRAY_DEFAULT_ALLOC 8

void intarray_resize(intarray tab, int newalloc);

intarray intarray_create(int len);

intarray standart_empty_intarray_create();

intarray empty_intarray_create(int alloc);

intarray standard_empty_intarray_create(void);

void intarray_create_aux(intarray tab);

void intarray_destroy(intarray tab);

int intarray_get(intarray tab, int index);

/* pour les tableaux de taille max fixe seulement */
void intarray_set(intarray tab, int index, int value);

/* comme intarray_set, mais modifie alloc si nécessaire */
void ext_intarray_set(intarray tab, int index, int value);

void intarray_add(intarray tab, int value);
/*
 *   Déplace un seul élément (très rapide).
 *   Attention : modifie l'ordre des éléments de tab.
 *   Si on souhaite que l'ordre reste inchangé,
 *   il faut appeler la fonction intarray_delete. */

void UNSORTED_intarray_delete(intarray tab, int index);
/*
 *   Déplace jusqu'à N éléments (dans le pire des cas),
 *     N étant la taille du tableau. */

void intarray_delete(intarray tab, int index);

int intarray_len(intarray tab);

void intarray_debug(intarray tab);

void ext_intarray_debug(intarray tab);

void intarray_print_positive_values(intarray tab);

int intarray_search(intarray tab, int n);

int intarray_nb_occurences(intarray tab, int n);

void intarray_tri_minimum(intarray tab);

intarray intarray_copy(intarray tab);

int intarray_sum(intarray tab);

float intarray_average(intarray tab);

float intarray_median (intarray tab);

/* retourne le résultat de la concaténation de T1 et T2 */
intarray intarray_concat(intarray T1, intarray T2);

/* retourne la plus petite valeur contenue dans tab */
int intarray_get_min(intarray tab);

/* retourne l'index de la plus petite valeur contenue dans tab */
int intarray_get_index_of_min(intarray tab);

/*
 *    retourne l'index de la plus petite valeur contenur dans tab,
 *    entre la case numéro n et la fin du tableau. */
int intarray_get_index_of_min_from(intarray tab, int n);

/* retourne la plus grande valeur contenue dans tab */
int intarray_get_max(intarray tab);

/* retourne l'index de la plus grande valeur contenue dans tab */
int intarray_get_index_of_max(intarray tab);

/*
 *    retourne l'index de la plus grande valeur contenur dans tab,
 *       entre la case numéro n et la fin du tableau. */
int intarray_get_index_of_max_from(intarray tab, int index);

/* tirage aléatoire d'entiers entre a et b pour créer un tableau de
 * taille n */
intarray intarray_create_random(int n, int a, int b);
#endif

J'ai également vérifier la fonction intarray_get_index_of_min_from(...)
Je ne vois aucun probleme de crochet.

int intarray_get_index_of_min_from(intarray t, int n) {
        int min_pos = n;
        for (int i = n; i < t->len; i++) {
                if (t->data[i] < t->data[min_pos])
                        min_pos = i;
        }
}

Hors ligne

#13 Le 26/04/2017, à 09:56

no_spleen

Re : Erreur expected '=', ',', ';', 'asm' or '__attribute__[RESOLU]

Salut,

Le problème avec intarray_get_index_of_min_from n'est pas liés aux crochets. C'est que tu l'as définie comme étant une fonction retournant un int, mais elle ne retourne rien. Donc, soit :

- Tu t'es trompé dans ta déclaration, et il faut la définir comme void
- Tu as oublié un return quelque part

Hors ligne

#14 Le 26/04/2017, à 10:18

plouf1221

Re : Erreur expected '=', ',', ';', 'asm' or '__attribute__[RESOLU]

Ok je vais corriger cela tout de suite, j'étais focalisé sur les crochets.
Il fait qu'il return min_pos.
Dans le premier fichier que j'ai publié et le second intarray.c cela y est j'ai du me trompé lorsque j'ai fait le copier/coller de la fonction.

Hors ligne