Discussion :

[lefevrelaumonier]

Bonjour,

est ce que l'un d'entre vous aurais la structure simple d'une fonction qui retourne un tableau à 2 dimensions.

Pour l'instant voici mon code :

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
 
#include <iostream>
#include <math.h>
using namespace std;
 
int ** multiplierParDeux(int a, int b)
{
    int **surface;
    surface[0][0] = a*2;
    surface[1][0] = b*2;
    surface[0][1] = a*3;
    surface[1][1] = b*3;
    return surface;
 
}
 
 
int main()
{
 
int ** values;
 
values = multiplierParDeux(2, 4);
cout << values[1][1]; 
 
 
}

Cela compile bien mais quand j’exécute avec un message du type :
"Structure function retour tableau.exe a cessé de fonctionner"

J'utilise dev C++

Merci beaucoup pour votre aide

[koala01]

Salut,

C'est normal...

la ligne

Code :

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

 int ** surface;

ne fais pas du tout ce que tu crois

Mais il y a tellement d'erreurs que je n'ai le courage que de te donner un seul et unique conseil : essaye de trouver un cours ou un tutorial sur le C++ parce que là, vraiment, tu fais du gros n'importe quoi, et je serais parti pour te donner un cours complet rien que pour te permettre de corriger les énormités que tu as écrites.

Comprends bien qu'il ne s'agit absolument pas de refuser de t'aider, loin s'en faut, il s'agit surtout de t'inciter à faire un minimum d'effort pour que non seulement tu ne finisses pas dégouté de ne pas comprendre nos réponses et pour éviter qu'une armée d'intervenant n'aie à passer des heures entières à t'expliquer des bases que tu peux trouver n'importe où.

Nous serons toujours là même pour t'expliquer les bases si tu ne les comprends pas par toi-même, mais il faut au moins que tu fasses l'effort d'essayer de les comprendre

[lefevrelaumonier]

lol merci

pourtant cela fonctionnait bien pour une version à une dimension.

Mais effectivement je suis débutant.

Merci pour ton "aide"

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
 
#include <iostream>
#include <math.h>
 
using namespace std;
 
int *multiplierParDeux(int a, int b)
{
    int *surface;
    surface[0] = a*3;
    surface[1] = b*3;
    return surface;
 
}
 
 
int main()
{
 
int * values;
 
values = multiplierParDeux(2, 4);
cout << values[1]; 
 
}

[koala01]

Si tu avais écrit, comme je le crains, une version à une dimension sous une forme proche de

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
 
int * multiplierParDeux(int a, int b)
{
    int *surface;
    surface[0] = a*2;
    surface[1] = b*2;
    return surface;
 
}
int main()
{
 
int * values;
 
values = multiplierParDeux(2, 4);
cout << values[1]; 
 
 
}

tu as déjà de la chance que ca ait fonctionné car uniquement parce que tu as eu la chance d'avoir un programme simplissime qui n'a pas du réutiliser la mémoire qui était utilisée à l'intérieur de la fonction

Le problème, c'est ton utilisation des pointeurs: Si tu tiens à poursuivre dans cette voie, renseigne toi au moins sur ce qui s'appelle "l'allocation dynamique de la mémoire" et l'usage correct des pointeurs

Mais saches que l'idéal reste souvent d'utiliser les conteneurs fournis par le standard pour s'éviter bien des soucis (je pense, par exemple, au std::vector dans le cas qui nous intéresse) et qu'il est souvent plus facile, quand on veut manipuler un tableau "plein" à deux dimension de X par Y éléments de manipuler en réalité un tableau à une seule dimension de X * Y élément en utilisant la formule numeroX * Y + numeroY

[lefevrelaumonier]

merci pour ton aide !
je vais explorer cela !

[lefevrelaumonier]

est ce que je m’éloigne de l'ignorance ultime avec cela ? ... ou je m'en rapproche à nouveau !

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
 
#include <stdio.h>
#include <stdlib.h>
 
int **matrice;
 
int fonct(int nLignes, int nColonnes)
{
 
  matrice = new int* [ nLignes ];
  for (int i=0; i < nLignes; i++)
    matrice[i] = new int[ nColonnes ];
 
   matrice[1][1] =100;
 
}
 
int main()
{
 
fonct(5,5);
printf("%d", matrice[1][1]);
 
}

[Bousk]

C'est moins pire, mais attention à libérer la mémoire allouée.
Le code n'est pas foncièrement faux en tous cas.

[koala01]

Le code est en tout cas beaucoup moins mauvais, à ceci près que:

1. Comme Bousk l'a signalé, il ne faut pas oublier de libérer la mémoire une fois que tu as terminé
2. Les variables globales, c'est mal

Mais il y a déjà une très nette amélioration

[lefevrelaumonier]

Bon je suis sur la bonne voie alors !
Merci beaucoup!!
Bonne journée

[lefevrelaumonier]

encore moi,

je me risque à la critique à nouveau (à croire que j'aime ça), mais j'aimerais avoir votre avis sur la manière dont j'ai codé le problème suivant, surtout pour l'aspect allocation de mémoire.

Selon vos conseils j'ai supprimé les variables globales, et vidé la mémoire.

Voici mon code, il me retourne le résultat désiré mais je voudrais avoir votre avis sur sa structure

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
 
#include <iostream>
#include <string>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
using namespace std;
 
float binomialTree(float **tree,
					float S0, 
				    float u, 
				    float d,
				    int nbStep)
 
{
 
	tree[0][0] = S0;	
 
	// arbre binomiale
	for (int j=1; j <= nbStep ;  j++)
		{tree[0][j]=tree[0][j-1] * u ;}
 
	for (int i=1; i <= nbStep ;  i++)
		{
		for (int j=1; j <= nbStep ;  j++)
			if (j >= i)
			{tree[i][j]=tree[i-1][j-1] * d;}
			else
			{tree[i][j]= 0;}	
		}
 
}
 
int main()
{
 
float S0 = 100, u = 1.1, d = 0.85;
int nbStep=15; 
 
float **tree;
 
// initialisation mémoire du tableau
tree = new float* [ nbStep + 1 ];
for (int i=0; i < nbStep + 1; i++)
	{tree[i] = new float[ nbStep + 1 ];}
 
binomialTree(tree,S0, u, d, nbStep);
 
// print
for (int i=0; i<=nbStep; ++i)
  {
  for (int j=0; j<=nbStep; ++j)
  	{printf("%-00005.1f ", tree[i][j]);}
  printf("\n");
  }
 
// vider mémoire
delete[] tree;
 
}

[koala01]

Ah, il y a du progres

Il reste, cependant, une erreur à signaler et une remarque à faire:

La remarque d'abord : tu devrais essayer d'utiliser des noms de variables / d'argument plus explicites, de manière ce qu'ils "auto documentent" ton code.

Cela rend la relecture beaucoup plus aisée, surtout quand le lecteur n'est pas celui qui l'a écrit ou quand tu relis ton code parfois plusieurs mois après l'avoir écrit

L'erreur ensuite: il reste une grave erreur de libération de la mémoire dans le sens ou tu fais deux allocations dynamique différentes :

• la première pour le pointeur de pointeur
• la seconde pour chaque pointeur qui va prendre place dans le pointeur de pointeur.

Tu dois donc avoir deux libérations de mémoire différentes, dans l'ordre inverse:

• la première pour chaque pointeur qui prend place dans le pointeur de pointeur
• la second pour le pointeur de pointeur lui-même

Autrement, tu as ce que l'on appelle "une fuite mémoire"

Ceci dit, tu as raison de soumettre ton code à la remarque, car on apprend beaucoup plus de ses erreurs grâce à des remarques constructives que par ce que l'on a tout de suite fait correctement

[lefevrelaumonier]

merci pour tout ces bons conseils ! j'en prends bonne note!
je vais libérer la mémoire !!
merci pour le temps consacré aux différentes réponses ...
bonne journée

[cob59]

Tu viens du monde MATLAB, lefevrelaumonier ?
Histoire de ne pas réinventer la roue et d'économiser un temps et une peine considérables, je te conseille d'utiliser une lib de calcul matriciel telle que OpenCV. Tu pourras allouer/redimensionner/dupliquer des matrices en un claquement de doigts, sans fuites mémoire. Et il est probable que la majorité des algos que tu t'échines à coder y soient déjà présents.

[koala01]

Tu viens du monde MATLAB, lefevrelaumonier ?
Histoire de ne pas réinventer la roue et d'économiser un temps et une peine considérables, je te conseille d'utiliser une lib de calcul matriciel telle que OpenCV. Tu pourras allouer/redimensionner/dupliquer des matrices en un claquement de doigts, sans fuites mémoire. Et il est probable que la majorité des algos que tu t'échines à coder y soient déjà

Je crois surtout que le but de lefevrelaumonier est, tout simplement, l'apprentissage du langage

Une fois qu'il auras acquis les bases, il sera bien temps de s'atteler à des problèmes réels

[cob59]

Je crois surtout que le but de lefevrelaumonier est, tout simplement, l'apprentissage du langage

Une fois qu'il auras acquis les bases, il sera bien temps de s'atteler à des problèmes réels

C'est peut-être juste un thésard qui veut porter ses algos MATLAB en code natif, sans trop perdre de temps ?

[koala01]

C'est peut-être juste un thésard qui veut porter ses algos MATLAB en code natif, sans trop perdre de temps ?

Il connait peut etre matlab, je le laisserais sagement répondre sur ce point, mais mon expérience au vu de la complexité des algorithmes mis en oeuvre me dit que c'est, surtout, pour apprivoiser le langage en partant de problèmes simples

Ceci dit, tu as tout à fait raison : si son intention est de partir sur du calcul matriciel, il lui sera largement utile de s'intéresser à des bibliothèques spécialisées dans ce genre de problèmes