une petite partie d'un code permettant de chnger quelques valeurs d'une matrice initialement nulle :
 
int matriceD (dPoint2D *p,matrice *la_matrice){
   matrice mat;
alloc_matrice(&mat,4,4);
intmatrice(mat);
 
mat[0][2]=p->y;
mat[1][3]=34;
 
*la_matrice=mat;
afficherMatrice(*la_matrice);
 
}
int main()
  matrice mat;
    matrice tmat;
    alloc_matrice(&mat,4,4);
Point2D p;    
    p.x=3;
    p.y=2;
  intmatrice(mat);
  matriceQ(&p,&mat);
  afficherMatrice(mat);
 return EXIT_SUCCESS;
  }
 
 
comme résultat j'la matrice suivante :
 0.000000 0.000000 2.000000 0.000000
 0.000000 0.000000 0.000000 34.000000
 34.000000 0.000000 0.000000 0.000000
 0.000000 0.000000 0.000000 0.000000
 
Ma question c pourquoi y 2 fois 34 alors que je n'ai demandé que d'affecter mat[1][3] par 34 !
voilà!
merci d'avance!

On veut tout le code réduit au minimum compilable montrant le défaut. L'erreur peut avoir des origines diverses...
 
 

ok ! je vais ajouter les fonctions qui manquent  
 double **matrice;
 typedef struct dPoint2D {
  double x;
  double y;
} dPoint2D;
 
 
 
 
double** alloc_matrice(matrice *mat,int xsize,int ysize){
 
  register int i;
 *mat=(matrice) malloc( sizeof(int *) * ysize );
  if ((*mat)==NULL) printf("probleme d'allocation memoire" );
 
 for(i=0;i<ysize;i++){
   (*mat)[i] =(double*) malloc( sizeof(int) *xsize );
    if ((*mat)[i]==NULL) printf("probleme d'allocation memoire" );
 
  }
 
return *mat;
}
 
 
 
void afficherMatrice(matrice mat){
  int i,j;
 
  for (i=0;i<4;i++){
    // printf("\n" );
    for (j=0;j<4;j++){
 
      printf(" %f",mat[i][j]);
 
    }
     printf("\n" );
}
}
 

chouette, on sait pourquoi ca plante (si ca s'affiche)
 

what ?
cast inutile et sizeof **mat tellement plus prudent
 

   
putchar par exemple

je crois avoir cerné l'origine du mauvais calcul ! à priori c'est la fonction allocation ! pourtant j'ai cru bien appliquer tes conseils( je m'adresse à  "Emmanuel D elahaye" ).

( Alors utilise le bouton [ ]-> )
 
Ton code est gravement endommagé... Commence par ça. Si tu ne comprends pas pose des questions.

Bonjour,
 
Petite question stupide concernant le passage de tableaux en parametre de fonction. Je lis ici et la que le C n'autorise pas le passage d'un tableau en parametre a une fonction. J'aimerai juste comprendre pourquoi le code suivant fonctionne:
 

 
Ok c'est laid, les arguments etant passes par copie, je risque d'avoir rapidemment des problemes de memoire. Mais qu'y a t'il de fondammentalement mauvais dans ce code?    
Merci d'avance pour vos reponses, et mes excuses pour les accents!

Non il n'y a pas de copie du tableau, lors de l'appel de fonction ton tableau est implicitement converti en pointeur sur l'adresse de se dernier (tu peux faire &testMatrix d'ailleurs c'est pareil)
 
Puis comme dans ta fonction tu a précisé que c'était un tableau, tu vas pouvoir l'utiliser comme tel (ça permet de simplifier l'écriture).
 
Mais tu n'utilises donc qu'un "pointeur", pas de copie du tableau, la preuve, le tableau original est modifié par tes fonctions.
 
PS : le deuxième argument du tableau dans ta fonction est indispensable pour savoir combien d'élément "sauté" pour passer à la ligne suivante mais le premier est inutile.

http://mapage.noos.fr/emdel/notes.htm#param_tab

Dans le code que tu donnes Emmanuel, ca veut dire quoi la virgule de cette ligne ?
 

 
J'ai pas fait de C depuis longtemps (Java all the time :x) et je ne me souviens pas avoir déjà vu ca :x

 
Bah, c'est l'opérateur ',' que tout le monde utilise dans for.  

L'execution est séquentielle.  
 
Je l'utilise ici pour 'atomiser' le code source, c'est à dire pour éviter ça:

Qui évolurait en

alors que

detection que l'on peut aussi instrumenter comme ceci

alors que

echapperait à l'instrumentation...
 
Donc, je tiens à "l'atomicité" de l'opération, d'où l'opérateur ',' (on est moins tenté d'insérer du code entre les deux instructions...)

dans ce cas pourquoi pas une macro ?

 
Les macros c'ets le mal

ce qui est mal c'est de confondre macro et fonction, la je veux savoir pourquoi dans ce cas ca serais mal ?? pour moi ca rendrais le code plus sur

J'ai effectvement ça dans ma bibliothèque:
 
http://mapage.noos.fr/emdel/clib/ed/inc/sysalloc.h

Mais on m'a fait remarqué que le paramètre était évalué 2 fois, ce qui est 'mal'. (Je dirais qu'il y a un point de séquence entre les deux, donc tout va bien...). Dans l'usage courant, il n'y a pas de risque, mais dans des cas tordus, il faut voir...
 
 
 
 

 
Pourquoi ?

ben imagine
FREE(p++)
 
edit: c'est juste un exemple, il y a sans doute bien plus tordu

 
   
 
C'est hideux, mais j'ai compris l'idée.  

Oui, c'est techniquement possible, mais qui ferait ça ? Un fou probablement...

Mais oui super idée  

 
genre un gars qui a un tableau de pointeurs et qui ve se la dilater 'code condensé' fait pour liberer les pointeurs

je sais c'est largement tiré par les cheuveux    mais sémantiquement FREE doit liberer et mettre à NULL un pointeur et il ne peut pas le garantir
 
c'est peut etre une connerie mais  ca ne resoudrais pas ce probleme ?
edit: non en fait c'etait une connerie

a la limite pourquoi pas faire
 

 
En C++, on passerai par un zoli tempalte et une surcharge de delete

une surcharge de delete en C++ peut etre pas, sinon comment on libere un pointeur constant ?

bonjour les gars je veut un programme qui camlcul l'inverse d'une matrice  
l'ai unn devoire a rendre qui comporte ce programme pourrier vou m'aider m
mmmmmeeeeeerrrrrcccciiiii    beaucop d'avence

j ai' oublier de vous dire un programme en c
merci

 
On n'est pas là pour faire tes devoirs (cf. la charte).

merci de m'avoire averti je nerecomenerai plus  
promis
 

a l'aide d'un ami jai reliser le programme qui calcul le determinant d'un e mat
le voici
#include <stdio.h>
#include <stdlib.h>
#define DIM 10
typedef float ligne[DIM];
typedef ligne matrice[DIM];
typedef float *pointeur;
long nb_appels;
 
void lecture(matrice t,int *lig)
/* lit une matrice (au clavier) */
 {
  int l,c;
  float f;
  puts("dimension de la matrice ?" );
  scanf("%d",lig);
  for (l=0;l<*lig;l++) for(c=0;c<*lig;c++)
   {
    printf("élément [%d,%d] ? ",l,c);
    scanf("%f",&f);
    t[l][c]=f;
   }
 }
void zero(matrice t,int dim)
/* met toute la matrice à 0 */
 {
  int i,j;
  for(i=0;i<dim;i++)for(j=0;j<dim;j++) t[i][j]=0;
 }
void unit(matrice t, int dim)
/* remplit la matrice unité (1 diagonale, 0 autre) */
 {
  int i;
  zero(t,dim);
  for(i=0;i<dim;i++) t[i][i]=1;
 }
void affiche(matrice t,int l)
/*  puts("affichage du tableau ligne par ligne :" ); */
 {
  int i,j;
  for(i=0;i<l;i++)
   {
    printf("ligne %d : ",i);
    for(j=0;j<l;j++) printf("%3.1f ",t[i][j]);
    printf("\n" );
   }
 }
void copiesauflc(matrice source,matrice dest,int dim,int ligavirer)
 {
  int l,c,ld=0;
  for (l=0;l<dim;l++) if (l!=ligavirer)
   {
    for (c=1;c<dim;c++) dest[ld][c-1]=source[l][c];
    ld++;
   }
 }
float determinant(matrice m,int dim)
 {
  matrice sous_m;
  int l,signe=1;
  float det=0;
  nb_appels++;
  if (dim=!1) return(m[0][0]);
  for(l=0;l<dim;l++)
   {
    copiesauflc(m,sous_m,dim,l);
    det+=signe*m[l][0]*determinant(sous_m,dim-1);
    signe=-signe;
   }
  return(det);
 }
void produit(matrice a,matrice b,matrice c,int dim)
/* calcul du produit */
 {
  int im,il,in;
  zero(c,dim);
  for(im=0;im<dim;im++)
    for(in=0;in<dim;in++)
      for(il=0;il<dim;il++)
        c[im][in]+=a[im][il]*b[il][in];
 }
void main(int argc,char *argv[])
 {
  int taille;
  matrice mat;
/*  lecture(mat,&taille);  */
      taille=atoi(argv[1]); /* test avec matrice unité, */
      unit(mat,taille);     /* au moins je connais le résultat*/
  affiche(mat,taille);
  printf("déterminant : %20.17f ",determinant(mat,taille));
  printf(" en %ld appels\n",nb_appels);
 }
mais ca ne marche pas corriger le pour moi

100 balles et un mars aussi?
 
- edites ton post et met ton code entre les balises cpp, c'est illisible.

- vire tes scanf
- met tes pointeurs à NULL une fois qu'ils servent plus
- commente ton code au niveau programme, fonction, paramètre, variable, portion de code pas clair
- indente ton code correctement  
- compile ton programme en faisant en sorte d'avoir les warnings (-Wall /Wall -w.. suivant ton compilateur) jusqu'à ce que justement il n'y est plus de warning
- utilise lint un coup dessus et corrige ce qui te parait opportunt
- et si tu n'as toujours pas trouver d'où vient l'erreur poste le message d'erreur
- apprend à te servir d'un débuggueur

A vos ordres, Chef !

• main() retourne int. Toujours.
• argc n'est pas testé. On ne sais pas si des arguments ont été passés...
• le domaine de l'argument 1 n'est pas testé.
• "if (dim = !1)" est probablement un erreur : "if (dim != 1)"
• les fonctions 'lecture()' et 'produit()' ne sont pas utilisées.

Sinon, c'est pas mal comme code. Quel est le problème exactement ?

je dois avoire une oeil de l'egggle pour voire toues ces erreures

MERCI

Ah, "un oeil de l'aigle"!  
 
Tu fais très fort... Les ravages de la méthode globale...

 
J'sais pas... Je suis de cette génération aussi.
Je pense plutôt que ce sont les ravages du "je veux tout, et tout de suite".