Rien ne s'affiche

**hazeul** · 11/06/2014, 12h25

Bonjour,

Je suis une débutante en programmation sous C++. Je voulais écrire une fonction qui génére des nombres aléatoires (leur nombre est "taille") à partir d'un intervalle donné (qui est sous la forme d'un tableau array contenant 2 éléments). et qui retourne ces nombres aléatoires dans un tableau de 2 dimensions (2 lignes et "taille" colonnes).
Lorsque je fais appel à la fonction en main et j'essaye d'afficher le tableau retourné rien ne s'affiche !! Merci d'avance pour votre 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
vector<vector<double>> rand_numbers(size_t taille,array<double,2> minmax){
	vector<vector<double>> T(2,vector<double> (taille));
    T.clear();
	for(size_t i(0);i<T.size();++i){
		for(size_t j(0);j<T[0].size();++j){
		T[i][j]=(minmax[0] + (minmax[1]-minmax[0])*(double)(rand()/(RAND_MAX + 1.0)));//
	}
	}
return T;
}
 
int main(){
vector<vector<double>> vek(2,vector<double>(20));
array<double,2> Bornes={-5,5};
vek=randum_numbers(20,Bornes);
 
for(size_t i(0);i<vek.size();++i){
	for(size_t j(0);j<vek[i].size();++j){
 
	cout << "le tableau vek est "<<vek[i][j] << endl;
}
}
return 0;
}

**PilloBuenaGente** · 12/06/2014, 09h11

Bonjour,

Ce qui me saute aux yeux c'est T.clear(); suivi du T.size();.
Le vecteur est vidé, il est donc de taille 0.

Le mieux dans ce cas est de tester ligne par ligne pour repérer l'algo qui ne fonctionne pas.

**hazeul** · 12/06/2014, 13h22

Merci pour la réponse PilloBuenaGente :
En fait j'utilise le T.clear() car j'ai lu ds un cours de cpp que après avoir crée un tableau vide, il peut contenir n'importe quoi. il faut d'abord le vider.
T.size() serait égale à 2 (le nombres de lignes)
T[0].size() le nombre de colonnes qui est la variables taille.

En fait j'ai essayé la compilation ligne par ligne, mais ça ne m'a pas trop aidé.

Merci de bien vouloir m'aider

**ternel** · 12/06/2014, 14h24

En C++, les classes de la bibliothèque standard (la STL) sont propres. Quand elles sont construites, elles contiennent des choses bien définies.
Par exemple, un vecteur est vide, et une array contient des 0.

Pour etre précis, cppreference dit:

constructor (implicitly declared)
default-constructs or copy-constructs every element of the array
(public member function)

autrement dit: les éléments sont construits avec leur valeur par défaut (0 pour les nombres) ou par copie (sous-entendu quand on fait une copie)

**PilloBuenaGente** · 12/06/2014, 14h39

Envoyé par hazeul

En fait j'utilise le T.clear() car j'ai lu ds un cours de cpp que après avoir crée un tableau vide, il peut contenir n'importe quoi. il faut d'abord le vider.

Cela vaut pour un tableau static (double[taille]) où les valeurs ne sont pas initialiser, le vecteur quant à lui est de taille zéro par défaut.

Si après avoir enlevé le clear() le problème reste le même, il faudrait vérifier les valeurs (par des simples cout <<) à plusieurs endroit pour voir là où ça coince.
Egalement peut être reposer le problème sur papier histoire d'avoir un algorithme clair.

(Le mieux ici serait peut-être quelque chose comme : std::vector<std::array<double, 2>>)

**ternel** · 12/06/2014, 14h54

Je voulais écrire une fonction qui génére des nombres aléatoires (leur nombre est "taille") à partir d'un intervalle donné (qui est sous la forme d'un tableau array contenant 2 éléments).
et qui retourne ces nombres aléatoires dans un tableau de 2 dimensions (2 lignes et "taille" colonnes).

C'est déjà bien compliqué, il y a plusieurs choses à faire.

Commence par créer une fonction simple, double random(double min, double max);, qui retourne un nombre aléatoire entre min et max.

Éventuellement, il serait utile de procéder avec une structure intermédiaire.

Code :

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

1
2
3
4
5
class Point {
public:
    const double x, y;
    Point(double x, double y) :x(x), y(y) {};
};

Tu pourras alors écrire simplement une autre fonction: Point random_point(double min, double max);.

Ce qui te permettrait d'écrire la fonction suivante, qui est autrement plus claire que ce que tu as fait:

Code :

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

1
2
3
4
5
6
7
std::vector<Point> points(size_t taille, double min, double max) {
    std::vector<Point> points(taille);
    for (int i=0; i < taille; ++i) {
        points.push_back( random_point(min, max) );
    }
    return points;
}

Envoyé par mon grand-père

Si c'est trop difficile, commence par faire un morceau simple, et sers-t-en.

Si par contre j'ai mal compris, il suffira de procéder de manière similaire:

D'abord la fonction d'aléatoire dans un intervalle,
puis une fonction générant N nombres alléatoires,
et enfin une seconde générant plusieurs lignes.

**hazeul** · 12/06/2014, 15h16

Merci pour vos réponses

En fait j'ai déjà créé 2 fonctions avant celle ci. Une qui retourne un vector d'une seul dimension et qui prend en paramètres des valeurs (doubles). après j'ai changé ces paramétres en un tableau array (qui est minmax) et ça a marché pour ces deux fonctions. Alors que quand j'essaye de modifier les valeurs de retour de façon à ce que j'aie un vector de 2 dimensions

ça ne marche plus !!!

En plus de ça j'ai une fenètre d'erreur windows qui s'affiche : le programme Nom_du_dossier.exe a cessé de fonctionner

Avez-vs déja rencontré ce problem ?

Mercii encore

**PilloBuenaGente** · 12/06/2014, 16h06

Envoyé par hazeul

En plus de ça j'ai une fenètre d'erreur windows qui s'affiche : le programme Nom_du_dossier.exe a cessé de fonctionner

C'est sans doute un accès à une case inexistante d'un vecteur.

**hazeul** · 13/06/2014, 10h53

Merci à vous tous

J'ai fais des modifications sur la fonction (grace à vos conseils bien sur) et maintenant ça marche !
Je pense que c'est surtout à cause du clear() et j'ai remplacé le T[0].size() par la variable taille directement !

Merci

**ternel** · 13/06/2014, 11h04

Montre nous ton nouveau code, nous pourrions te donner plus de conseils.

**hazeul** · 17/06/2014, 10h46

Envoyé par leternel

Montre nous ton nouveau code, nous pourrions te donner plus de conseils.

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
 
#include<iostream>
#include<vector>
#include<array>
#include<cstdlib>
using namespace std;
 
 
 
 
vector<vector<double>> randum_numbers(size_t taille,array<double,2> minmax){
 
	vector<vector<double>> T(2,vector<double> (taille));
 
	for(size_t i(0);i<2;++i){
		for(size_t j(0);j<T[i].size();++j){
		T[i][j]=(minmax[0] + (minmax[1]-minmax[0])*(double)(rand()/(RAND_MAX + 1.0)));//
	}
	}
return T;
}
 
int main(){
 
 
vector<vector<double>> vekky(2,vector<double>(20));
array<double,2> Bornes={-5,5};
size_t taille(20);
 
vekky=randum_numbers(taille,Bornes);
 
for(size_t i(0);i<vekky.size();++i){
	for(size_t j(0);j<taille;++j){
	cout << vekky[i][j] <<endl;
}
}
 
return 0;
}

**ternel** · 17/06/2014, 11h56

Plusieurs conseils cosmétiques:

choisi entre le français et l'anglais: "random_numbers" et "taille" sont incompatibles
ajoute un argument pour avoir un nombre de ligne paramétrables.
Pour parcourir un vecteur, la dernière norme (c++11) propose le for étendu.

D'autres conseils.
Il vaut mieux éviter de copier pour rien, surtout des vecteurs.
Ainsi, une fonction randomize (ou aleatoiriser), pourrait prendre une référence de vecteur, et remplacer toutes ses valeurs.

Voila ce que ça donnerait (en bonus, un "meilleur" affichage d'une grille):

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
#include<iostream>
#include<vector>
#include<array>
 
using namespace std;
 
void aleatoiriser(vector<double> & nombres, array<double,2> const& minmax){
	for (double& n : nombres) {
			n=(minmax[0] + (minmax[1]-minmax[0])*(double)(rand()/(RAND_MAX + 1.0)));
		}
	}
}
 
void aleatoiriser(vector<vector<double>> & grille, array<double,2> const& minmax){
	for (vector<double>& ligne : grille) {
		aleatoiriser(ligne, minmax);
	}
}
 
int main() {
	array<double,2> bornes={-5,5};
 
	vector<vector<double>> vekky(2, vector<double>(20));
	aleatoiriser(vekky, bornes);
 
	for (vector<double> const& ligne : vekky) {
		for (double d : ligne) {
			cout << d <<' ';
		}
		cout<<endl;
	}
 
	return 0;
}

Pour ta culture, tu peux aussi templater le code pour devenir indépendant du type de variable (double ou int, même chose...)
Je rajoute la présentation pour faire un en-tête.

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
//début de l'en-tête, si tu en fais un
#ifndef INCLUDE__PROTECTION__random_grid
#define INCLUDE__PROTECTION__random_grid
//maintenant, je sais que l'en-tête ne sera pas inclus deux fois.
#include<ostream>
#include<vector>
#include<array>
 
#include<cstdlib>
template <typename T>
void aleatoiriser(std::vector<T> & nombres, std::array<T,2> const& minmax){
	for (T& n : nombres) {
			n=(minmax[0] + (minmax[1]-minmax[0])*(T)(std::rand()/(RAND_MAX + 1.0)));
		}
	}
}
 
template <typename T>
void aleatoiriser(std::vector<std::vector<T>> & grille, std::array<T,2> const& minmax){
	for (std::vector<T>& ligne : grille) {
		aleatoiriser(ligne, minmax);//détection automatique de aleatoiriser<T>(ligne, minmax)
	}
}
 
template <typename T>
std::ostream& operator<<(std::ostream& stream, std::vector<std::vector<T>> const& grille) {
	for (auto const& ligne : grille) {//auto permet de ne pas préciser le type, vu qu'il est contraint par le reste du code
		for (auto const& d : ligne) {//de même
			stream << d <<' ';
		}
		stream<<'\n';
	}
	return stream;
}
#endif
//fin de l'en-tête
 
 
#include<iostream>
#include <ctime>
 
//#include "random_grid.hpp"
 
//"using namespace ...;" ne doit pas être utilisé dans un en-tête. 
using namespace std;
 
int main() {
	srand(time(NULL));
 
	array<double,2> bornes={-5,5};
	vector<vector<double>> vekky(2, vector<double>(20));
	aleatoiriser(vekky, bornes);
	cout << vekky << flush;
 
	array<int,2> ibornes={-5,5};
	vector<vector<int>> entiers(2, vector<int>(20));
	aleatoiriser(entiers, bornes);
	cout << entiers << flush;
 
	return 0;
}

En C++11, il existe aussi l'en-tête <random>, que je te laisse chercher

Pense à rajouter l'option --std=c++11 (pour gcc) et son équivalent pour visual studio.

**hazeul** · 17/06/2014, 13h06

Merci bien Mr leternel de vos précieux conseils
Vous m'avez beaucoup aidé. Je vous en suis très reconnaissante

**hazeul** · 17/06/2014, 13h18

En fait juste pour m'assurer. Je travaille sur eclipse car j'ai lu que c'est le meilleur IDE pour le developpement en C++. Sinon il est trop lourd...
Qu'est ce que vous en pensez?

**ternel** · 17/06/2014, 13h51

Que le bon outil est celui qui fait ce dont tu as besoin, et tient bien dans ta main.

code::blocs est très bien aussi.

Personnellement, j'ai passé des années avec trois fenêtres notepad++ et un terminal.
J'ai arrêté, parce que je me suis mis à avoir de vraiment gros projets.

Rien ne s'affiche

C++

Discussions similaires

Partager

Partager