Discussion :

[informatik]

bonjour je n arrive pas a faire passer l argument mat à mes fonctions
code blocks me dit que mat n'est ni un array ni un pointeur... comment faire ? merci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include "main.h"
 
const long MAX=100,MIN=0;
int main()
{
 
    long n=4,vect[n],mat[n][n];
    srand(time(NULL));
	printf("calcul sur les vecteurs et matrices\n");
    printf("calcul aleatoire du vecteur et de la matrice\n");
    aleatvect(vect,n);
    affichevect(vect,n);
    aleatmat(mat,n);
    affichemat(mat,n);
    printf("calcul de la norme du vecteur");
    printf("%lf",normvect(vect,n));
 
	return 0;
}
 
 
void aleatvect(long *vect, long n)  //cree un vecteur de nb entiers aleatoires
{
    long i;
    for(i=0;i<n;i++)
    {
        vect[i]=rand()%(MAX-MIN+1)+MIN;
    }
}
 
void affichevect(long *vect,long n) //affiche les composantes du vecteur
{
    long i;
    printf("affichage du vecteur :\n");
    for(i=0;i<n;i++)
    {
        printf("vect[%ld]=%ld\n",i,vect[i]);
    }
}
 
void aleatmat(long *mat,long n) // cree une matrice carree de nb entiers aleatoires
{
    long i,j;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            mat[i][j]=rand()%(MAX-MIN+1)+MIN;
        }
    }
}
 
void affichemat(long *mat, long n)  //affiche la matrice
{
    long i,j;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            printf("mat[%ld][%ld]=%ld\t",i,j,mat[i][j]);
        }
        printf("\n");
    }
}
 
 
double normvect(long *vect, long n) //calcule la norme du vecteur
{
    long i;
    double norm=0.0;
    for(i=0;i<n;i++)
    {
        norm +=pow(vect[i],2);
    }
    return sqrt(norm);
}

[Pragmateek]

Et en remplacant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

long *mat

par:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

long (*mat)[n]

?
En définissant "n" en globale et en compilant avec un compilateur c99.

[informatik]

merci ça semble marcher même si mon header a du etre changé je ne peut plus mettre une dimmension n quelconque mais n=4 par exemple :

void aleatvect(long *vect, long n);
void affichevect(long *vect,long n);
void aleatmat(long (*mat)[4],long n);
void affichemat(long (*mat)[4], long n);
double normvect(long *vect, long n);

à moins que tu saches aussi resoudre ce pb

une question : pourquoi ça marche ?merci

[Pragmateek]

"n" indique la taille supposée du tableau passé en paramètre ce qui permet de la passer via "n" sans avoir un deuxième argument dans la fonction:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include<stdio.h>
#include<stdlib.h>
 
static int n; 
 
void f(long (*t)[n]){
     printf("La taille de t est : %d\n",sizeof(*t)/sizeof(int));
     return;
     }
 
int main(int argc,char* argv[])
{
 
n=10;
long t[10][10];
 
f(t);
 
system("pause");
return EXIT_SUCCESS;
}

Pour le header, peut être qu'en mettant à son début:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

extern int n;

Lorsqu'un tableau est indiqué en tant que paramètre d'une fonction il est remplacé par "un pointeur du type des éléments du tableau pointant sur le premier élément du tableau".
Donc si "m" est un tableau à deux dimensions, un tableau de tableau en C, contenant des "long" il sera remplacé par "un pointeur sur un tableau de long", noté "long (*m)[]", pointant sur le premier sous tableau de "m".
Les VLA (Variable Length Array) ont été ajouté au C avec la norme C99.
Ils permettent de créer des tableaux dont la taille est évalué dynamiquement, qui donc n'est pas obligé d'être connue à la compilation.

[diogene]

Si on ne dispose pas d'un compilateur admettant les VLA, il est obligatoire de spécifier une constante dans la déclaration.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void aleatmat(long (*mat)[4],long n);

est le prototype correct.
Mais la fonction ne peut traiter que des tableaux de type long tab[...][4] ce qui est très restrictif. La raison est que le compilateur a besoin de cette dimension (4) pour calculer les adresses des éléments du tableau.
Une possibilité pour s'affranchir de cette restriction est d'avoir une déclaration

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void aleatmat(long *mat,long n);

mais dans ce cas,
1- l'appel à cette fonction doit inclure un cast du tableau sur un long *
2- la fonction ne peut plus utiliser la notation mat[i][j] et le programmeur doit à la place coder lui-même le calcul des adresses : mat[i*n+j]

[Pragmateek]

Et il faut aussi indiquer l'autre dimension:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void aleatmat(long *mat,long n,long m);

1- l'appel à cette fonction doit inclure un cast du tableau sur un long *

Ou passer l'adresse du 1er élement du 1er sous tableau.
D'ailleurs est-ce que la norme garantie que le cast d'un "long(*)[]" en "long*" donne ce résultat?

[pititom51]

pourquoi ne pas utiliser simplement en paramètre un long **mat qu'on aurait alloué dynamiquement dans le main.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
int main()
{
    int i;
    long n = 4, *vect, **mat;
 
    vect = (long *) malloc(n * sizeof(long));
 
    mat = (long **) malloc(n * sizeof(long *));
    for (i = 0; i < n; i++)
      mat[i] = (long *) malloc(n * sizeof(long));
 
 
    srand((int) time(NULL));
 
 
    printf("calcul sur les vecteurs et matrices\n");
 
    printf("\ncalcul aleatoire du vecteur et de la matrice\n");
 
    aleatvect(vect, n);
    affichevect(vect, n);
 
    aleatmat(mat, n);
    affichemat(mat, n);
 
    printf("\ncalcul de la norme du vecteur\n");
    printf("%lf", normvect(vect, n));
 
    return 0;
}
 
void aleatmat(long **mat, long n) // cree une matrice carree de nb entiers aleatoires
{
    long i, j;
 
    for (i = 0; i < n; i++)
        for (j = 0; j < n; j++)
            mat[i][j] = rand() / ((double) RAND_MAX) * (MAX - MIN) + MIN;
}
 
void affichemat(long **mat, long n)  //affiche la matrice
{
    long i, j;
 
    printf("\naffichage de la matrice :\n");
    for( i = 0; i < n; i++)
    {
        for(j = 0; j < n; j++)
            printf("mat[%ld][%ld]=%ld\t", i, j, mat[i][j]);
        printf("\n");
    }
}

[Médinoc]

Parce que c'est pas si facile que ça à allouer. Moi, je serais plutôt pour la thèse "une allocation par dimension" :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
long ** AllocTab2Dim(size_t dim1, size_t dim2)
{
	long ** ppRetour = calloc(dim1, sizeof(*ppRetour));
	if(ppRetour)
	{
		long * pLongs = calloc(dim1*dim2, sizeof(*pLongs));
		if(pLongs)
		{
			size_t i;
			for(i=0 ; i<dim1 ; i++)
				ppRetour[i] = pLongs+(i*dim2);
		}
		else
		{
			free(ppRetour);
			ppRetour = NULL;
		}
	}
	return ppRetour;
}
 
 
void FreeTab2Dim(long **ppLongs)
{
	free(*ppLongs);
	free(ppLongs);
}