Discussion :

[blitz_]

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 :

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
 
// 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 :

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

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

[koala01]

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

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 :

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

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 :

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
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 :

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 <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

[blitz_]

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 :

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
 
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]

[Goten]

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

[blitz_]

Ok donc maintenant j'ai ca :

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
 
#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 !

[Invité]

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

[blitz_]

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 :

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
#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}
            };