erreur non comprise

Marsh Posté le 19-10-2013 à 10:04:07

Bonjour, je suis débutant en C, et j'ai voulu crée un programme qui fait une copie d'un tableau d'entier de taille N vers un autre, pour cela , j'ai crée 4 fonctions: fonction.h fonction.c le Makefile et main.c , dont les voici .Mais ,à chaque fois que je compile, le compilateur m'affiche :
Pour le Makefile

Code :

exe :main.o fonction.o
gcc -o exe main.o fonction.o -Wall -lm
fonction.o:fonction.c
gcc -c fonction.c
main.o :main.c fonction.h
gcc -c main.c
clean:
rm *.o exe

Pour la fonction :"fonction.h"

Code :

#ifndef fonction_h
#define fonction_h
int taille(char *s);
int *initTAB(int n);
int copie(int *tab,int N);
#endif

Pour la fonction :"fonction.c"

Code :

#include<stdlib.h>
#include<stdio.h>
#include<math.h>
#include<string.h>
int copie(int *tab,int N)
{
int *t=(int*)malloc(N*sizeof(int)); // c'est ce talbeau qui sera en "return"!!
int k;// l'incrementation
for (k=0;k<N;k++)
{
*(t+k)=*(tab+k);
}
return(t); // t, c'est le tableau retourné
}

Et quand je compile( sous geany, avant de de le "make" ), il m'affiche cet avertissement:

Code :

fonction.c:14:3: attention : return makes integer from pointer without a cast [enabled by default]

C'est quand je le caste en int (j'ai pas compris le pourquoi!!) que l'erreur disparait!

Idem pour la fonction main.c :

Code :

#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<string.h>
#include "fonction.h"
int main()
{
int q;
int n=5;
int *tab;
//tab=initTAB(n);
int source[5]={6,5,4,3,2};
tab=copie(source,n);
for(q=0;q<n;q++) printf("tab[%d]=%3d\n",q,*(tab+q));
return 0;
}

le compilateur me dit:

Code :

main.c:16:5: attention : assignment makes pointer from integer without a cast [enabled by default]

Je n'arrive pas à voir d'où provient mon erreur!!

Message cité 1 fois

---------------
Mohamed ABDEREMANE

Reply

Marsh Posté le 19-10-2013 à 10:04:07

Reply

Marsh Posté le 19-10-2013 à 11:27:17

Bonjour

Tout d'abord, vous avez dit que la fonction copie retourne un int et non int*, donc vous ne pouvez pas écrire ensuite :

Code :

int *t=(int*)malloc(N*sizeof(int)); // c'est ce talbeau qui sera en "return"!!

pour corriger cet erreur, vous avez deux choix, soit :

copie retournera un tableau de int (int*)
ou bien void et elle prendra en argument 3 paramètres : la source, la destination et la taille du tableau.

en retournant un pointeur vers int il faut être prudent quand même pour ne pas tomber dans le cas où vous retournez une adresse locale qui n'est plus "utilisable" !
Sinon, la façon la plus simple de faire c'est d'utiliser la fonction memcpy comme ceci :

Code :

#include<stdio.h>
#include<stdlib.h>
int main() {
int src[5] = {6, 5, 4, 3, 2}, dest[5];
memcpy(dest, src, sizeof(dest));
for (int count = 0; count < 5; count++)
printf("tab[%d] = %d\n", count, dest[count]);
}

Message cité 1 fois
Message édité par snack3r le 19-10-2013 à 11:52:14

---------------
C++ and Java, say, are presumably growing faster than plain C, but I bet C will still be around. ― Dennis Ritchie

Reply

Marsh Posté le 20-10-2013 à 10:10:30

Bonjour,

les syntaxes *(tab+k) sont à proscrire car inutilement "obfuscatrice" : la syntaxe tab[k] est bien plus lisible...

Reply

Marsh Posté le 20-10-2013 à 21:17:38

lavela a écrit :

Code :

int copie(int *tab,int N)
 {
     int *t=(int*)malloc(N*sizeof(int)); // c'est ce talbeau qui sera en "return"!!
     int k;// l'incrementation
     for (k=0;k<N;k++) 
     {
        *(t+k)=*(tab+k);
     }
     return(t); //     t, c'est le tableau retourné
 }

dreameddeath a écrit :

Bonjour,

les syntaxes *(tab+k) sont à proscrire car inutilement "obfuscatrice" : la syntaxe tab[k] est bien plus lisible...

Bonjour

Ta fonction "copie" est prévue pour renvoyer un int or elle renvoie "t" qui est un "int étoile". D'ailleurs tu le dis toi-même, tu renvoies le "talbeau". Or un "talbeau" ce n'est pas un int mais une adresse. Dommage que tu aies mis des commentaires sans ensuite en tenir compte...

Sinon pour la remarque de dreameddeath c'est exact. Il n'y a absolument aucun avantage à écrire *(t+x) au lieu de t[x]. Je pense que t'as essayé de mettre en application une règle qui dit que passer par un pointeur c'est plus rapide que déréférencer un "talbeau" ; ce qui est vrai à condition alors de passer par un pointeur et non par un calcul

Exemple

Code :

int* copie(int *tab,int N)
 {
     int *t=(int*)malloc(N*sizeof(int)); // c'est ce talbeau qui sera en "return"!!
     int i;// l'incrementation
     int *src;    // Le pointeur source
     int *dest   // Le pointeur destinataire
     for (i=0, src=tab, dest=t;i<N;i++) 
        *dest=(*src);
     return(t); //     t, c'est le tableau retourné
 }

Est-ce que tu vois la différence ? Je m'adresse à des pointeurs qui ont la bonne adresse et non à des adresses que je dois calculer à chaque itération...

snack3r a écrit :

en retournant un pointeur vers int il faut être prudent quand même pour ne pas tomber dans le cas où vous retournez une adresse locale qui n'est plus "utilisable" !

Là ça va puisque c'est une adresse allouée. Simplement l'appelant devra prendre soin, lui, de libérer l'allocation une fois qu'il n'en a plus besoin...

snack3r a écrit :

Sinon, la façon la plus simple de faire c'est d'utiliser la fonction memcpy comme ceci :

Je pense qu'il veut s'exercer pour apprendre et comprendre et non passer par un outil déjà tout fait...

Message édité par Sve@r le 20-10-2013 à 21:24:00

---------------
Vous ne pouvez pas apporter la prospérité au pauvre en la retirant au riche.

Reply

erreur non comprise

Sujets relatifs:

Leave a Replay