erreur non comprise

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : erreur non comprise

lavela

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

Publicité

snack3r

Mohamed AHMED

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

dreameddeath

Bonjour,

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

Sve@r

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.

FORUM HardWare.fr

Programmation

erreur non comprise

Sujets relatifs
xls erreur sur code "If Target =" lors d'insertion de ligne	gestion d erreur, rollback
Erreur 500 NullPointerException	erreur MSQL sur mon site
[VBS] Erreur lancement script VBS	erreur de segmentation sur matrice
A supprimer : doublons	Boucle while en erreur
PHPExcel erreur ddl client version
Plus de sujets relatifs à : erreur non comprise

Page générée en 0.069 secondes