Bonsoir ! Désolé de vous déranger...

 quand je compile sur ubuntu j'ai ce warning (sur windows tout fonctionne bien):

 warning: ‘N’ is used uninitialized in this function [-Wuninitialized] 

   N->m = M->n; 

typedef struct Matrice Matrice;
struct Matrice
{
	int m,
		n;
	double *v;
};




Matrice *transpose(Matrice *M) // on transpose une matrice
{
  int i,j ;
  Matrice *N;
  N->m = M->n;
  N->n = M->m;
  N->v = malloc(N->m*N->n*sizeof(double));
  for (i = 0; i < M->n; i++)

    {
      for (j = 0; j < M->m; j++)
        {
            N->v[(i * M->m) + j] = M->v[(j * M->n) + i];
        }
    }
  return N;
}

comment résoudre le problème ?

Je ne sais pas initialiser la structure comme elle est personnalisée

Merci d'avance

-
Edité par PierreVana 14 décembre 2018 à 23:25:48

Hello,

Ligne 16: que vaut N ? On n'en sait rien, N n'est pas initialisé (pas de malloc())

PierreVana a écrit:

(sur windows tout fonctionne bien)

je voudrais que N soit juste une matrice que je remplisse au fur et à mesure de la fonction ! 

Du coup pour moi N est un pointeur vers une matrice vide non ?

-
Edité par PierreVana 14 décembre 2018 à 23:41:56

Non. N pointe sur une adresse en mémoire, mais laquelle ?

Comment as-tu fais pour M ?

-
Edité par edgarjacobs 15 décembre 2018 à 0:21:15

M est juste une matrice. je fais donc transpose(&M)

Merci de tes réponses grâce à toi j'ai réussi à contourner le problème :

je remplace :

Matrice *N;

par 

Matrice P;
Matrice *N = &P;

mais pourquoi quand on créé un pointeur sur un int comme:

int *a;

ça marche bien mais pas pour un type personnalisé ?

Non : int* a; est un pointeur et ne doit pas être déréférencé s'il n'a pas été initialisé sur une adresse existante.

Mais pourquoi, saperlipopette, veux-tu absolument utiliser un pointeur ? Ça fait plus je-m-y-connais ?

Tu n'a vraiment pas besoin d'un pointeur ! Utillise P.n, P.m et P.v ! Pourquoi te faire ch.... à faire *N=P et N->n, N->m et N->v ?

-
Edité par edgarjacobs 15 décembre 2018 à 16:58:59

PierreVana a écrit:

C'est dans l'énoncé je dois rendre un pointeur sur matrice ... tu penses qu'en faisant P.n etc et si je retourne &P ça marche ?

Ah, voilà une information supplémentaire. Et non, retrounrer l'adresse de P ne fonctionnera pas: P est une variable locale à la fonction, et donc détruite à la fin de la fonction.

Mais ceci va fonctionner

Matrice *transpose(Matrice *M) {
	....
	Matrice *N;

	N=malloc(sizeof(*matrice));		// ou malloc(sizeo(Matrice))
	N->m = M->n;
	....
	
	return N;
}

A l'appelant de tout libérer.

-
Edité par edgarjacobs 17 décembre 2018 à 20:25:26

Non,

Une fonction ne doit jamais retourner l'adresse d'un variable interne, car on aurait un pointeur sur une variable qui n'existe plus (dangling pointer).
S'il faut retourner une zone pointable c'est qu'elle doit être allouée. En changeant la ligne 15 par : 

Matrice *N = malloc(sizeof(Matrice));

Il y aura alors besoin de 2 free() pour libérer cette matrice.

grilled

-
Edité par Dalfab 17 décembre 2018 à 20:55:00