C++

Forum

 
Problem vector 3D

alejandrojimenez (15)
Helo everyone today i have a doubt about the code below , it's about the management of the vector in 3D , afteer show you the code then i have the specifics questions about it , and you'll tell me if you can help me , so the code:

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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
#include <iostream>
#include <string>
#include <vector>
using namespace std;
// Pour simplifier
typedef string Forme   ;
typedef string Couleur ;

class Brique
{
private:
  Forme   forme   ;
  Couleur couleur ;

public:
  /*****************************************************
    Compléter le code à partir d'ici
  *******************************************************/
Brique (Forme a, Couleur b):forme(a),couleur(b){}
Forme get_forme()const{return forme;}
Couleur get_couleur() const{return couleur;}

ostream& afficher(ostream& sortie) const
{
    sortie<<"( "<<forme<<" , "<<couleur<<" )"<<endl;
    return sortie;
    }
};

ostream& operator <<(ostream& sortie , Brique const & val)
{
return val.afficher(sortie);
}

class Construction
{
friend class Grader;
private:
vector<vector<vector<Brique>>> contenu;
public:
Construction (Brique a);

unsigned int get_contenu_size()const{return contenu.size();}
unsigned int get_contenu_size(int i)const{return contenu[i].size();}
unsigned int get_contenu_size(int i, int j)const{return contenu[i][j].size();}
Brique get_contenu(int i=0, int j=0, int k=0)const{return contenu[i][j][k];}

vector<vector<vector<Brique>>> get_contenuVect()const{return contenu;}

ostream& afficher(ostream& ) const;

void operator +=(Construction const & a);

};
ostream& operator <<(ostream& sortie , Construction const & tmp)
{
      return tmp.afficher(sortie);
}
ostream& Construction::afficher(ostream& os) const
{
    unsigned int i(0),j(0),k(0);
     if (contenu.empty())
         return os;
     else
     {
        for(i =0; i<contenu.size();i++){
            os << "Couche " << i << endl;
             for(j = 0 ;j<contenu[i].size();j++){
               for(k = 0;k<contenu[i][j].size();k++){
                      os<< contenu[i][j][k];
                }
                }
                }

             return os;
    }

 }

void Construction::operator +=(Construction const &a)
{

     for(unsigned int j =0; j< a.contenu.size() ; j++){

     for(unsigned int k=0; k < a.contenu[j].size(); k++) {

                 contenu[k].push_back(a.contenu[j][k]);

                                               }
                                           }

  }

const Construction operator+(Construction a,Construction const& b)
{
a+=b;
return a;
}
/**
const Construction operator*(unsigned int n, Construction const& a)
{

return a;
}

const Construction operator/(unsigned int n, Construction const& a)
{
}

const Construction operator%(unsigned int n, Construction const& a)
{
}
*/
Construction::Construction(Brique a):contenu (1, vector < vector <
Brique > > (1,vector<Brique> (1, a))) {}
/*******************************************
 * Ne rien modifier après cette ligne.
 *******************************************/

int main()
{
  // Modèles de briques
  Brique toitD("obliqueD", "rouge");
  Brique toitG("obliqueG", "rouge");
  Brique toitM(" pleine ", "rouge");
  Brique mur  (" pleine ", "blanc");
  Brique vide ("                 ", "");


  /**unsigned int largeur(4);
  unsigned int profondeur(3);
  unsigned int hauteur(3); // sans le toit
*/
  // on construit les murs

  Construction maison(mur+mur+mur);
  Construction maison2(mur);
  //cout<<maison;
  cout<<maison ;

  //Construction maison( hauteur / ( profondeur % (largeur * mur) ) );
/**
  // on construit le toit
  Construction toit(profondeur % ( toitG + 2*toitM + toitD ));
  toit ^= profondeur % (vide + toitG + toitD);

  // on pose le toit sur les murs
  maison ^= toit;

  // on admire notre construction
  cout << maison << endl;
*/
  return 0;
}



Questions:

So let's say that i , j , k are the dimensions but for the moment i can't get the result of the + operator
If you see in the main i have this:

Construction maison(mur+mur+mur);
cout<<maison ;

if i compile and execute i obtain:

Couche 0
( pleine , blanc )
( pleine , blanc )
( pleine , blanc )

But this is wrong , because i should have something like this:

Couche 0
( pleine , blanc ) ( pleine , blanc ) ( pleine , blanc )

And i couldn't make it .I know that the error is because I'm making a tour in the vector with the dimension i , and i should do it the k dimension , but really I've done a lot of mixes and all the combinations that i thought andonly obtain :

Couche 0
( pleine , blanc )

Or a segmentation fault , I spend a lot of time to this exercise and i feel blocked , if you could help me that would be nice , the problemformeis in the function afficher() or with the += operator.
Any way thanks for your help and your comments
alejandrojimenez (15)
Finally i found the problem it was in Brique declaration , i had a <<endl; that i didn't need it.

So I'm going to mark this like resolved.
Reasearcher (4)
Hello,

i have to do this same work, it still two days for the due date ;(

i have written my version but it did'nt work well!
can you publish your version to have some idea and to correct my version ?
or to send me by email?

Thanks a lot.
Best regards.
mystere (2)
Hello!

I have a problem with an exercise of the same kind (Tower of Hanoi). I know that for my exercise there are several solutions on the net but I would like to find by myself that's why I would like to have the solution for this exercise to better understand the logic of the 3D. Can you send me the last version you have ?

Thx!
alejandrojimenez (15)
Hi researcher , welll , sure I'm going to publish my version , but it doesn't work totally, the problem is in the main because of this:

toit ^= profondeur % (vide + toitG + toitD);

But if you do something like this:

toit ^= profondeur % (vide + toitG + toitD+vide);

it works perfectly.

So here is my code:

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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
 
#include <iostream>
#include <string>
#include <vector>
using namespace std;

// Pour simplifier
typedef string Forme   ;
typedef string Couleur ;

class Brique
{
private:
  Forme   forme   ;
  Couleur couleur ;

public:
  /*****************************************************
    Compléter le code à partir d'ici
  *******************************************************/
Brique (Forme a, Couleur b):forme(a),couleur(b){}
Forme get_forme()const{return forme;}
Couleur get_couleur() const{return couleur;}

ostream& afficher(ostream& sortie) const
{
	if((forme =="                 ")&& (couleur=="")){
	sortie<<"                 ";
     }	
	else
	{	
	sortie<<"("<<forme<<" , "<<couleur<<") ";
								   }
	return sortie;
	
	}
};

ostream& operator <<(ostream& sortie , Brique const & val)
{
return val.afficher(sortie);
}

class Construction
{
friend class Grader;

private:

vector<vector<vector<Brique>>> contenu;

public:

Construction (Brique a);

unsigned int get_contenu_size()const{return contenu.size();}
unsigned int get_contenu_size(int i)const{return contenu[i].size();}
unsigned int get_contenu_size(int i, int j)const{return contenu[i][j].size();}
Brique get_contenu(int i=0, int j=0, int k=0)const{return contenu[i][j][k];}

vector<vector<vector<Brique>>> get_contenuVect()const{return contenu;}

ostream& afficher(ostream& ) const;

 
void operator +=(Construction const &);
 
void operator -=(Construction const &);

void operator ^=(Construction const &);
};
ostream& operator <<(ostream& sortie , Construction const & tmp)
{	  
      return tmp.afficher(sortie);
}

ostream& Construction::afficher(ostream& os) const
{
	unsigned int j(0),k(0);//i(0),
     if (contenu.empty())
         return os;
     else 
     {
        //for (i=0; i < contenu.size(); i++)
         for (size_t i(contenu.size()-1); i >= 0 && i < contenu.size(); --i)
         {
         // unsigned int i1 =contenu.size()-1-i;
          
            cout <<" Couche " << i<<endl;
             for(j = 0 ;j<contenu[0].size();++j)
             {             
				 
               for(k = 0;k<contenu[0][0].size();++k)
               {
                      
                      os<< contenu[i][j][k];
                }
               cout<<endl;
                }
                }
             
             return os;
                }
 }

void Construction::operator +=(Construction const& c2)
{
    unsigned int hauteur1, profondeur1;
	unsigned int hauteur2, profondeur2, largeur2;


    hauteur1=contenu.size(); //hauteur de la construction a
	hauteur2=c2.contenu.size(); //hauteur de la construction c2
  //largeur1=contenu[0][0].size();//largeur de la construction a
	largeur2=c2.contenu[0][0].size();//largeur de la construction a

	if(hauteur2>=hauteur1)
	{
	    profondeur1=contenu[0].size();//profondeur de la construction a
	    profondeur2=c2.contenu[0].size();//profondeur de la construction a
	
	if(profondeur2>=profondeur1)
	{

			for(unsigned int hauteur=0; hauteur<hauteur1 ; ++hauteur)
			{
                for(unsigned int profondeur=0; profondeur<profondeur1; ++profondeur)
				{				
					//largeur2=c2.contenu[0][0].size();//largeur de la construction a
					for(unsigned int largeur=0; largeur<largeur2 ; ++largeur)
					{	
						contenu[hauteur][profondeur].push_back(c2.contenu[hauteur][profondeur][largeur]);
	                
					}				
				}
			}
		
	}
    }		
}
    	
void Construction::operator -=(Construction const& c2)
{
	unsigned int hauteur1;
	unsigned int hauteur2, profondeur2;
    unsigned int hauteur, profondeur;
    
	hauteur1=contenu.size(); //hauteur de la construction a
	hauteur2=c2.contenu.size(); //hauteur de la construction c2
	profondeur2=c2.contenu[0].size();//profondeur de la construction a
	if(hauteur2>=hauteur1)
	{
		//profondeur1=contenu[0].size();//profondeur de la construction a
		//profondeur2=c2.contenu[0].size();//profondeur de la construction a
		
			for(hauteur=0; hauteur<hauteur1 ; ++hauteur)
			{
                for(profondeur=0; profondeur<profondeur2; ++profondeur)
				{	
						contenu[hauteur].push_back(c2.contenu[hauteur][profondeur]);
								        	
				}
			}
		
	}
	
}
void Construction::operator ^=(Construction const& c2)
{
 
    unsigned int hauteur1;
    unsigned int hauteur;
   
	hauteur1=c2.contenu.size(); 
		
			for(hauteur=0; hauteur<hauteur1 ; hauteur++)
			{
               
				contenu.push_back(c2.contenu[hauteur]);
                 								        	
			}
	}


const Construction operator+(Construction a,Construction const& b)
{
a+=b;
return a; 
}

const Construction operator-(Construction a,Construction const& b)
{
a-=b;
return a; 
}

const Construction operator^(Construction a,Construction const& b)
{
a^=b;
return a;
	}

const Construction operator*(unsigned int n, Construction const& a)
{
Construction b=a;
for (unsigned int i=1;i<n;i++) b+=a;
return b;
}


const Construction operator/(unsigned int n, Construction const& a)
{
Construction b(a);
for (unsigned int i=1;i<n;i++) b^=a;
return b;
}

const Construction operator%(unsigned int n, Construction const& a)
{
Construction b=a;
for (unsigned int i=1;i<n;i++) b-=a;
return b;
}

Construction::Construction(Brique a):contenu (1, vector < vector < Brique > > (1,vector<Brique> (1, a))) {}
/*******************************************
 * Ne rien modifier après cette ligne.
 *******************************************/


int main()
{
  // Modèles de briques
  Brique toitD("obliqueD", "rouge");
  Brique toitG("obliqueG", "rouge");
  Brique toitM(" pleine ", "rouge");
  Brique mur  (" pleine ", "blanc");
  Brique vide ("                 ", "");

  unsigned int largeur(4);
  unsigned int profondeur(3);
  unsigned int hauteur(3); // sans le toit

  // on construit les murs
  Construction maison( hauteur / ( profondeur % (largeur * mur) ) );

  // on construit le toit
  Construction toit(profondeur % ( toitG + 2*toitM + toitD ));
  toit ^= profondeur % (vide + toitG + toitD);
  
  // on pose le toit sur les murs
  maison ^= toit;

  // on admire notre construction
  cout << maison << endl;

  return 0;
}


If you can fix it tha would be amazing .
Reasearcher (4)
Thank you so much for help :)
Ok i will see your version.. If I find the fault, I will publish it here

i see that you function work from 4 elements:
toit ^= profondeur % (vide + toitG + toitD+4+5....);
i think that the problem is here:
const Construction operator+(Construction a,Construction const& b)

so here

void Construction::operator +=(Construction const& c2)

Bests.
Last edited on
Londoner (2)
Hello guys,
I reviewed the script that alejandrojimenez posted and I have modified it to make it works without the 
 
 
toit ^= profondeur % (vide + toitG + toitD+vide);


You can see that the problem was is the method afficher


Here is the script:
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
 
#include <iostream>
#include <string>
#include <vector>
using namespace std;

// Pour simplifier
typedef string Forme   ;
typedef string Couleur ;

class Brique
{
private:
  Forme   forme   ;
  Couleur couleur ;

public:
  /*****************************************************
    Compléter le code à partir d'ici
  *******************************************************/
Brique (Forme a, Couleur b):forme(a),couleur(b){}
ostream& afficher(ostream& sortie) const;
};
ostream& Brique::afficher(ostream& sortie) const {
	if(!couleur.empty()) {
		return sortie << "(" << forme << ", " << couleur << ") ";
	}
	else {
		return sortie << forme ;
	}
}
ostream& operator <<(ostream& sortie , Brique const & val)
{
return val.afficher(sortie);
}

class Construction
{
friend class Grader;

private:

vector<vector<vector<Brique>>> contenu;

public:

Construction (Brique a);
ostream& afficher(ostream& ) const;
void operator +=(Construction const &);
void operator -=(Construction const &);
void operator ^=(Construction const &);
};
ostream& Construction::afficher(ostream& os) const
{
	unsigned int j(0),k(0);//i(0),
     if (contenu.empty())
         return os;
     else 
     {
         for (size_t i(contenu.size()-1); i >= 0 && i < contenu.size(); --i)
         {
            cout <<"Couche " << i<<" :"<<endl;
             for(j = 0 ;j<contenu[i].size();++j)
             { 
               for(k = 0;k<contenu[i][j].size();++k)
               {                      
                 os<< contenu[i][j][k];
                }
               cout<<endl;
                }
                }
             
             return os;
                }
 }


ostream& operator <<(ostream& sortie , Construction const & tmp)
{	  
      return tmp.afficher(sortie);
}

void Construction::operator +=(Construction const& c2)
{
    unsigned int hauteur1, profondeur1;
	unsigned int hauteur2, profondeur2, largeur2;
    hauteur1=contenu.size(); //hauteur de la construction a
	hauteur2=c2.contenu.size(); //hauteur de la construction c2
  //largeur1=contenu[0][0].size();//largeur de la construction a
	largeur2=c2.contenu[0][0].size();//largeur de la construction a

	if(hauteur2>=hauteur1)
	{
	    profondeur1=contenu[0].size();//profondeur de la construction a
	    profondeur2=c2.contenu[0].size();//profondeur de la construction a
	
	if(profondeur2>=profondeur1)
	{
			for(unsigned int hauteur=0; hauteur<hauteur1 ; ++hauteur)
			{
                for(unsigned int profondeur=0; profondeur<profondeur1; ++profondeur)
				{				
					//largeur2=c2.contenu[0][0].size();//largeur de la construction a
					for(unsigned int largeur=0; largeur<largeur2 ; ++largeur)
					{	
						contenu[hauteur][profondeur].push_back(c2.contenu[hauteur][profondeur][largeur]);
	                
					}				
				}
			}
		
	}
    }		
}
    	
void Construction::operator -=(Construction const& c2)
{
	unsigned int hauteur1;
	unsigned int hauteur2, profondeur2;
    unsigned int hauteur, profondeur;
    
	hauteur1=contenu.size(); //hauteur de la construction a
	hauteur2=c2.contenu.size(); //hauteur de la construction c2
	profondeur2=c2.contenu[0].size();//profondeur de la construction a
	if(hauteur2>=hauteur1)
	{		
			for(hauteur=0; hauteur<hauteur1 ; ++hauteur)
			{
                for(profondeur=0; profondeur<profondeur2; ++profondeur)
				{	
						contenu[hauteur].push_back(c2.contenu[hauteur][profondeur]);
								        	
				}
			}
		
	}
	
}
void Construction::operator ^=(Construction const& c2)
{
    unsigned int hauteur1;
    unsigned int hauteur;
	hauteur1=c2.contenu.size(); 
			for(hauteur=0; hauteur<hauteur1 ; hauteur++)
			{
				contenu.push_back(c2.contenu[hauteur]);
			}
}

const Construction operator+(Construction a,Construction const& b)
{
a+=b;
return a; 
}

const Construction operator-(Construction a,Construction const& b)
{
a-=b;
return a; 
}

const Construction operator^(Construction a,Construction const& b)
{
a^=b;
return a;
}

const Construction operator*(unsigned int n, Construction const& a)
{
Construction b=a;
for (unsigned int i=1;i<n;i++) b+=a;
return b;
}


const Construction operator/(unsigned int n, Construction const& a)
{
Construction b(a);
for (unsigned int i=1;i<n;i++) b^=a;
return b;
}

const Construction operator%(unsigned int n, Construction const& a)
{
Construction b=a;
for (unsigned int i=1;i<n;i++)
b-=a;
return b;
}

Construction::Construction(Brique a):contenu (1, vector < vector < Brique > > (1,vector<Brique> (1, a))) {}
/*******************************************
 * Ne rien modifier après cette ligne.
 *******************************************/


int main()
{
  // Modèles de briques
  Brique toitD("obliqueD", "rouge");
  Brique toitG("obliqueG", "rouge");
  Brique toitM(" pleine ", "rouge");
  Brique mur  (" pleine ", "blanc");
  Brique vide ("                 ", "");

  unsigned int largeur(4);
  unsigned int profondeur(3);
  unsigned int hauteur(3); // sans le toit

  // on construit les murs
  Construction maison( hauteur / ( profondeur % (largeur * mur) ) );

  // on construit le toit
  Construction toit(profondeur % ( toitG + 2*toitM + toitD ));
  toit ^= profondeur % (vide + toitG + toitD);
  
  // on pose le toit sur les murs
  maison ^= toit;

  // on admire notre construction
  cout << maison << endl;

  return 0;
}


Please tell me if it helps.

Thanks
Reasearcher (4)
Hello,

on my machine, it works.
When i submit my code, i have:
fatal error in "test_construction_op_plus_eq": memory access violation at address: 0xfffffffffffffff8: no mapping at fault address
Please, have you an idea about this error, it still one day!

Thanks a lot.
Bests.
Last edited on
Londoner (2)
Hello Researcher,

The method operator+= has an issue. I think we have to adapt it because at his stage we always take the first hauteur and profondeur of the contenu, so, of the first Brique of the contenu.

I also think that operator-= will have the same issue.

I will investigate on my side... Because I am still stuck here as well.

Let us know if you find the solution.
Reasearcher (4)
No, i can't find a solution ! i'm blocked really!

Let me know if you find a solution please. (it still only one day)

Bests.
mystere (2)
Your attribute "contenu" is private. Isn't it an issue with accessing to a private attribute?
I'm beginning in C++ but it seems that your error message concerns memory access so it can be a problem with pointer/references...
Topic archived. No new replies allowed.