Tableaux C, classes et Templates

Version imprimable

Bonjour,

Je suis capable de recuperer la taille d'un tableau C via des templates, mais en 3 étapes, j'aurai voulu savoir s'il etait possible de le faire en une seule... Voici mon code (qui compile et marche) :

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
 
// Un parametre
class Parametre
{
public:
    int pname;
    int param;
};
// Un ensemble de parametres
class Parametres
{
public:
    std::vector<Parametre> params;
 
    template<std::size_t N>
    const Parametres& operator= (const Parametre (&params)[N])
    {
        for(const Parametre* i = params; i < params + N ; ++i)
        {
            this->params.push_back(*i);
        }
        return *this;
    }
};
// Instanciation - etape1 :
Parametre p[] = 
{
    {5,2},
    {1,2},
    {3,4}
};
// Instanciation - etape2 :
Parametres params;
// Instanciation - etape3 :
params = p; // avec le p defini dans le bloc précédent

Au final, je voudrais :

Code:

1
2
3
4
5
 
// Le top : 
params = {{5,2},{1,2}};
// ou alors
Parametres params = p;

Cela est-il réalisable ?

Merci d'avance pour vos réponses et conseils !
B

Salut,

A vrai dire, j'ai un peu de mal à comprendre le but de la manœuvre...

Si tu crée un tableau de manière statique comme tu le fait dans ton exemple, tu as encore bien plus facile de "simplement" compter le nombre d'élément que tu y met, et de créer une variable qui représente cette valeur quelque part.

Si tu crées ton tableau de manière dynamique, tu sera de toutes manières obligé de maintenir quelque part:
la taille allouée pour le tableau
le nombre d'éléments que tu as déjà inséré

Bref, quoi qu'il en soit, tu connaitra les différentes valeurs à un moment où un autre :D

Par contre, si l'idée est en fait de récupérer ces données dans une des collections de la STL (std::vector, par exemple), il faut savoir qu'elles proposent toutes une série de constructeurs assez sympa, comme, par exemple, celui qui prend un itérateur sur le début d'une collection et un itérateur sur... ce qui suit la fin de la collection.

Ainsi, tu pourrait parfaitement envisager un code proche de
Code:

1 2 3 4 5 6 7 Parametre p[] = { {5,2}, {1,2}, {3,4} }; std::vector<Parametre> params(p, p+3);
ou, si tu veux l'encapsuler dans une classe, avoir quelque chose proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class Parametres { public: Parametres (){} // constructeur par défaut template <typename iterator> Parametres(iterator beg, iterator end):tab_(beg,end){} private: std::vector<Parametre> tab_; }; int main() { Parametre p[] = { {5,2}, {1,2}, {3,4} }; Parametres others(p,p+3); }
Enfin, nouvelle norme te permet d'utiliser les vector de manière strictement identique à ce que l'on fait avec les tableaux C style:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #include <iostream> #include <vector> struct Parametre { int x; int y; }; int main() { std::vector<Parametre> p = { {5,2}, {1,2}, {3,4} }; std::cout<<"taille de p: "<<p.size()<<std::endl; for(size_t i=0;i<p.size();++i) std::cout<<p[i].x<<" "<<p[i].y<<std::endl; }
Encore faut il alors que tu utilise un compilateur suffisamment récent pour pouvoir en tirer parti ;)

Salut,

Ta dernière proposition est intéressante, puisque si j'encapsule mon vector dans une classe (mais je me contente du coup d'un typedef), alors je suis capable de faire ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 class Parametre { public: int pname; int param; }; typedef std::vector<Parametre> Parametres; // et donc en theorie : Parmetres p = { {5,2}, {1,2}, {3,4} }; // exactement ce que je veux !
Ceci dis je n'arrive pas à compiler ton dernier exemple ou ce que je propose (avec gcc4.4). Mais ma théorie est-elle fondée ?

[EDIT] Ah si c'est bon je compile et mon design marche ! Pour info dans codeblocks : Project/Build Options ; Onglet Compiler settings puis cocher la case "have g++ follow the coming C++0x ISO C++ language standard [-std=c++0x] dans la liste de compiler Flags [/EDIT]

24/04/2010, 18h29
Goten

Normal, std::vector ne supporte pas la liste d'initialization. Sauf avec la prochaine norme (C++0x)

Ok donc maintenant j'ai ca :
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 #include <iostream> #include <vector> class Parametres { struct Parametre { int x; int y; }; public: std::vector<Parametre> params; Parametres& operator= (const std::vector<Parametre> v) { this->params = v; return *this; } }; int main() { Parametres p1; p1 = { {1,2}, {3,4} }; }
qui ne compile pas et c'est exactement ce qu'il me faudrait (la structure parametre cachée)
voila ce que me dis le compilo :

In function ‘int main()’:

main.cpp|26|error: no match for ‘operator=’ in ‘p1 = {{1, 2}, {3, 4}}’

main.cpp|13|note: candidates are: Parametres& Parametres:: operator= std::vector<Parametres:: Parametre, std::allocator<Parametres:: Parametre> >)

main.cpp|4|note: Parametres& Parametres:: operator=(const Parametres&)

Puis-je contourner cette erreur ?
Merci d'avance !

25/04/2010, 17h40
Invité

Il suffit de remplacer le paramètre "vector" par "initializer_list" sans rien changer d'autre.

Bien oui effectivement la liste d'initialisation fonctionne pour la construction mais pas pour l'affectation ?

Voici un bout de code pour ceux que ca intéresse. Je me contenterai de la construction, cela me convient deja suffisamment. Merci à tous pour votre aide !

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
#include <iostream>
#include <vector>
#include <initializer_list>
 
#include <GL/gl.h>
using namespace std;
class TexParametersi
{
    struct TexParameteri
    {
        int target;
        int pname;
        int param;
    };
 
    std::vector<TexParameteri> _params;
 
public:
 
    TexParametersi(){}
    // Ca marche
    TexParametersi(const std::initializer_list<TexParameteri>& p)
    {
        _params = p;
    }
    // Ca marche pas ?
    TexParametersi& operator= (const std::initializer_list<TexParameteri>& p)
    {
        this->_params = p;
        return *this;
    }
};
 
// Fonctionne
TexParametersi tparams =
{
    {GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST},
    {GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST}
};
// Ne fonctionne pas !
TexParametersi tparams2;
tparams2 =  {
                {GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR},
                {GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR}
            };

26/04/2010, 15h45
koala01
Citation:

Envoyé par blitz_

Bien oui effectivement la liste d'initialisation fonctionne pour la construction mais pas pour l'affectation ?

Ben, ca a un petit coté de tout à fait normal, non :question:

L'initialisation se fait... lors de la construction :D

L'affectation quant à elle peut prendre plusieurs formes, allant d'une sémantique de mouvement au copy'n swap, en passant par... l'affectation pure et simple :P

Selon tes besoins, tu peux:
- Laisser l'opérateur d'affectation "tel quel", et donc profiter de l'affectation "pure et simple" (à condition que l'ensemble des membres de ta classe disposent eux-même d'un opérateur d'affectation correct)
- soit envisager le copy'n swap, si tu manipule, entre autres, des pointeurs nus
- définir un opérateur d'affectation utilisant la sémantique de mouvement si tu veux éviter les copies inutiles lorsque tu passe une variable temporaire pour l'affectation