Discussion :

[PilloBuenaGente]

bonjour, pardonnez mon intrusion,

sans c++11, comment est t-il possible de créer un vecteur d'une structure avec des membres constants sans passer par des pointeurs ?

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
#include <vector>
 
struct S_Foo {
        S_Foo( const float x ) : x( x ) {}
        float x;
};
 
class C_Foo {//Marche sans soucis avec des classes
public:
        C_Foo( const float x ) : x( x ) {}
        const float X() const { return x; }
private:
        float x;
};
 
int main() {
        std::vector < C_Foo > cfootab;
        cfootab.push_back( C_Foo(5));
        cfootab[0].x = 3;// Erreur cfootab[0].x est "constant" (pas d'accès public)
 
        std::vector < S_Foo > sfootab;
        sfootab.push_back( S_Foo(5));// comment rendre sfootab[0].x constant ?
        sfootab[0].x = 3;// modification possible de x
 
        return 0;
}

Merci par avance.

[gbdivers]

Salut

A mon avis, sans C++11, je crois que ce n'est pas possible...

[PilloBuenaGente]

C'est assez curieux, quand un objet à une sémantique de valeur, ne devrait-on pas ne pas pouvoir modifier ses membres ?!

[ternel]

Si ce n'est pas copiable et assignable, vector est inutilisable.

[PilloBuenaGente]

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
#include <vector>
 
struct Foo {
public:
        Foo( const float x ) : x( x ) {}
        const float x;
};
 
int main() {
        Foo c(1.0);             //ok
        Foo c2(c);              //ok
        Foo c3 = c2;            //ok
 
        vector <Foo> fTab;      //ok
        fTab.push_back(1.0);    //pas ok
 
        return 0;
}

C'est copiable et assignable mais il refuse.
Une classe sans setter avec des membres non constants est-elle considérée comme constante ?
Car dans ce cas là le vecteur marcherait et on respecterait la sémantique !?

[Médinoc]

^Ceci est copiable, mais pas assignable. J'entends déjà Visual gueuler "could not generate assignment operator".

[ternel]

En effet, assignable, ce serait

Code :

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

1
2
3
4
5
int main() {
        Foo c(1.0);             //ok
        Foo c2(2.0);              //ok
        c = c2; //PAS OK DU TOUT
}

[PilloBuenaGente]

Merci à vous
Je vais rééésayer d'installer c++11..

[gbdivers]

Tu utilises quel compilateur ?

[PilloBuenaGente]

GCC sur code::blocks.
(Je suis sur windows (par nécessitée), beaucoup on l'air d'utiliser VS, qui lui est à jour je crois, mais c'est encore microsoft )

[gbdivers]

GCC sur code::blocks.
(Je suis sur windows (par nécessitée), beaucoup on l'air d'utiliser VS, qui lui est à jour je crois, mais c'est encore microsoft )

En fait non, le support du C++ est moins avancé sur VS que sur GCC. Tu as quelle version de GCC ? Dans tous les cas, tu actives simplement le support du C++11 en ajoutant la directive -std=c++11. Ensuite, les fonctionnalités disponibles dépendent de ta version (voir http://cpp.developpez.com/gbdivers/cpp11/)

[PilloBuenaGente]

version 4.7.1 apparemment.

Code :

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

1
2
        Display(const Display&) = delete;
        Display& operator= (const Display&) = delete;

warning: defaulted and deleted functions only available with -std=c++11 or -std=gnu++11 [enabled by default]

Également je met ça en attente, j'ai au début tellement tout installé n'importe comment que je ne m'y retrouve plus, je formate, réessaye, et reviendrais vers vous en cas de pépins

Merci !

[koala01]

version 4.7.1 apparemment.

Code :

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

1
2
        Display(const Display&) = delete;
        Display& operator= (const Display&) = delete;

Également je met ça en attente, j'ai au début tellement tout installé n'importe comment que je ne m'y retrouve plus, je formate, réessaye, et reviendrais vers vous en cas de pépins

Merci !

Il faut que tu ailles dans les options du projet de code::blocks (menu "project" -> "build options...") et que tu coche la case "have g++ folow the C++11 ISO c++ standard (-std=c++11)"

Maintenant, on arrivait à éviter la copie et l'affectation de classes bien avant que C++11 n'y mette son grain de sel avec les fonction marquées "=delete"

L'idée est que l'on déclarait (SANS LES DEFINIR!!!) le constructeur par copie et l'opérateur d'affectation dans l'accessibilté privée, sous une forme proche de

Code :

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

1
2
3
4
5
6
7
class MaClasse
{
    /* ...*/
    private:
        MaClasse(MaClasse const &);   // déclaré, mais pas défini
        MaClasse & operator = (MaClasse const &); // déclaré mais pas défini
};

Nous obtenions alors une merveilleuse erreur du type de "( copy ctor / operator =) is private in this context" et, dans le pire des cas (lorsque la copie/ l'affectation était demandée par une fonction membre), nous obtenions une erreur de référence non définie au plus tard à l'édition des liens

[PilloBuenaGente]

Ce n'était qu'un warning....inoffensif..(manque de vocabulaire anglais)
En fait je l'ai depuis un baille
Merci à vous d'avoir persisté !!!

Oui d'ailleurs, j'utilisais ce constructeur de copie et d'affectation dans beaucoup de mes classes, comment savoir avec un "= delete", qu'a un moment donné on ai voulu la copier ou l'affecter si il n'y a plus d'erreurs ?

[Médinoc]

Il y aura toujours une erreur de compilation si on essaie, elle sera même peut-être plus explicite.

[PilloBuenaGente]

Merci ! ! C'est repartit !

[oodini]

A mon avis, sans C++11, je crois que ce n'est pas possible...

Et en C++11 ?...

[gbdivers]

En faisant rien Suffit de laisser le compilateur faire son boulot

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
#include <vector>
using namespace std;
 
struct Foo {
public:
        Foo( const float x ) : x( x ) {}
        const float x;
};
 
int main() {
        Foo c(1.0);             //ok
        Foo c2(c);              //ok
        Foo c3 = c2;            //ok
 
        vector <Foo> fTab;      //ok
        fTab.push_back(1.0);    //pas ok
 
        return 0;
}

En C++03, tu crées un objet par défaut puis fait une assignation. Tu as l'erreur suivante avec un const :

Code :

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

error: non-static const member ‘const float Foo::x’, can’t use default assignment operator

En C++11, l'objet est déplacé au lieu d'être copié, donc pas de problème

Remarque : push_back va faire une conversion implicite de double en Foo et faire un move. Et si on utilise par défaut "explicit" (ce qui devrait être le cas par défaut, sauf raison sémantique), alors ça compile pas. Il est préférable d'utiliser emplace_back ici