Discussion :

[Seabirds]

Bonjour à tous et à toutes !
Je fais mes tous premiers pas sur C++ et j'ai houlaaa... au moins quatre jours de recul !

Voilà, j'ai besoin d'avoir un tableau 2D dont on ne connaît pas à l'avance les dimension ni les valeurs au moment de la compilation... Donc j'ai essayé de créer des classes en utilisant std::vector.

On dirait que au moins le constructeur par défaut fonctionne puisque quand je commente l'étape d'impression dans le main je n'ai pas d'erreur. Mais je ne parviens à imprimer le résultat sur la console on dirait que ma méthode print est boîteuse (segmentation fault, core dumped)...

Mais je n'ai pas l'impression de chiper les indices du tableau en dehors de l'intervalle de définition... Quelqu'un aurait-il un avis sur ce qui se trame dans ce petit bout de code ?

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
 
 
#include <iostream>
#include <string>
#include <vector>
#include"Vector2D.h"
 
using namespace std;
 
int main()
{
     Vector2D layer;
    layer.print();
 
    return 0;
}

Dans le .h :

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
 
#ifndef VECTOR2D_H_INCLUDED
#define VECTOR2D_H_INCLUDED
#include<vector>
 
class Vector2D
{
    public :
 
    Vector2D();
    Vector2D(int nrow, int ncol);
    ~Vector2D();
    void print();
 
 
    private :
 
    int m_nrow;
    int m_ncol;
    std::vector< std::vector<int> > m_vec ;
 
};
 
 
#endif // VECTOR2D_H_INCLUDED

Dans le .cpp :

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
 
#include<vector>
#include<string>
#include<iostream>
#include "Vector2D.h"
 
using namespace std;
 
Vector2D::Vector2D() : m_nrow(5), m_ncol(5)
{
    std::vector< std::vector<int> > m_vec(
    m_nrow,
    std::vector<int>(m_ncol, 0));
}
 
Vector2D::Vector2D(int nrow, int ncol) : m_nrow(nrow), m_ncol(ncol)
{
    std::vector< std::vector<int> > m_vec(
    m_nrow,
    std::vector<int>(m_ncol, 0));
}
 
Vector2D::~Vector2D()
{
    // Rien à mettre: pas d'allocation dynamique !
}
 
void Vector2D::print()
{
 
    for(int i =0; i< m_nrow; i++){
        for(int j =0; j< m_ncol; j++){
            cout << m_vec[i][j] << "   ";
        }
        cout << endl;
    }
}

Je sais que il y a des manières plus élégantes de parcourir le vector (d'après ce que j'ai compris les itérateurs sont plus sympas, mais je ne suis pas parvenu à trouver la syntaxe pour parcourir 2 dimensions) mais ce sera pour après, déjà là j'aimerais bien réussir avec ma solution barbare... sauf contre-indication majeure évidemment
Merci par avance !

[prgasp77]

Code C++ :

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

std::vector< std::vector<int> > m_vec(...);

Devine ce qu'il se passe ici

[Seabirds]

Ah bah on dirait que je viens de trouver le problème grâce à ton aide, merci !

On dirait que le constructeur kiffait pas des masses toucher directement à m_vec. Quand je remplace par :

Code :

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

1
2
3
4
5
6
 
    std::vector< std::vector<int> > fog(
    m_nrow,
    std::vector<int>(m_ncol, 6));
 
    m_vec= fog;

il est soudainement moins contrarié...
Mais je ne suis pas certain de comprendre pourquoi :/

[jo_link_noir]

Je vais te répondre par 2 questions:
- Que fais dans une fonction int i = 0; ?
- Que fais dans une fonction i = 0; ?
(Tu peux ensuite remplacer int par ton vector de vector et comparer).

Ou si tu préfères: Comment on déclare une nouvelle variable ? Comment on utilise une variable ?

Après on parlera de la liste d'initialisation.

[prgasp77]

En concordance avec mes traditions ancestrales, je répondrai par une question (voire deux) :

Qu'est-ce que ce code signifie ?

Code :

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

std::vector< std::vector<int> > fog(...)

Qu'est-ce que ce code signifie ?

Code :

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

std::vector< std::vector<int> > m_vec(...)

[Seabirds]

Cool des questions !

Code :

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

1
2
std::vector< std::vector<int> > fog(...)
int i = 0

On déclare une variable fog ou i avec un type particulier et on l'initialise en suivant.

Code :

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

std::vector< std::vector<int> > m_vec(...)

On déclare une variable membre (alors que ça a déjà été fait dans le .h : c'est grave ?) puis on initialise la valeur de m_vec avec ce qu'il y a dans les parenthèses (ça marche pô mais en tout cas c'était le but recherché ^^).

Donc en gros la liste d'initialisation sert à initialiser des variables membres qui ont déjà été déclarées, donc pas la peine d'essayer de les redéclarer dans le cpp. Vrai ?
Et du coup, en suivant la logique de vos questions, en fait le code suivant marche aussi et évite de passer par une variable intérmédiaire:

Code :

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

1
2
3
4
5
 
Vector2D::Vector2D() : m_nrow(5), m_ncol(5), m_vec(std::vector< std::vector<int> >(m_nrow, std::vector<int>(m_ncol, 6)))
{
 
}

J'ai dit une bêtise ?

[jo_link_noir]

Code :

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

std::vector< std::vector<int> > fog(...)

On déclare une variable fog un type particulier

Oui

Code :

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

std::vector< std::vector<int> > m_vec(...)

On déclare une variable membre

Non


2 syntaxes identiques dans un contexte identique (corps de fonction) vont produire 2 comportements identiques.
Donc les 2 lignes créent une variable locale. S'il y a un membre avec le même nom, bah ce n'est pas grave, il serra caché.

Concernant la liste d'initialisation, il faut toujours passer par là pour construire les membres. Car dans le corps de la fonction, ils sont déjà construits et la seule chose possible est de les modifier.
Il y a une grosse nuisance: tous les membres ne sont pas modifiables, certains membres n'ont pas de constructeurs par défaut.

[Seabirds]

Ok c'est noté !

Il y a une grosse nuisance: tous les membres ne sont pas modifiables, certains membres n'ont pas de constructeurs par défaut.

Heu ça par contre j'ai pas compris ?

[jo_link_noir]

Par exemple, une référence n'a pas de constructeur par défaut et ne peut être construite que dans la liste d'initialisation:

Code :

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

1
2
3
4
5
6
7
8
9
struct S { 
  int & i ;
  S(int & ii) { i = ii; } //erreur
};
 
struct S { 
  int & i ;
  S(int & ii) : i (ii) { } //ok
};

La phrase est mal exprimée, il faut surtout retenir que pour initialiser un membre il n'y qu'un endroit: la liste d'initialisation. Le corps du constructeur ne permet que de modifier les membres.

[Seabirds]

Super là j'ai compris !
Merci beaucoup à tous pour vos questions-réponses !!!