initialisation automatique d'un tableau membre d'une classe

Version imprimable

15/11/2014, 14h01
jackk

initialisation automatique d'un tableau membre d'une classe

Bonjour,

Dans un programme, on peut définir un tableau lors de sa déclaration. Ex:

Code:

unsigned char tab[] = {1, 2, 8, 11};

Quel est le moyen le plus simple pour définir ce tableau s'il est membre d'une classe? On peut évidemment définir un à un les éléments du tableau dans le constructeur, ou définir un tableau local dans le constructeur et le recopier dans le tableau membre, mais j'aurais voulu savoir s'il existait un moyen de le définir en une seule opération.

Merci.
15/11/2014, 23h08
Ehonn

Bonjour

Sans trop prendre de risque, je peux dire : dans la liste d'initialisation du constructeur.
Depuis C++11, tu peux initialiser directement les données membres lors de la déclaration.
Pour les tableaux qui ont une taille qui varie, tu peux utiliser std::vector. Si la taille est connue à la compilation, depuis C++11, std::array existe.
16/11/2014, 00h35
jackk
Tout d'abord, merci pour ta réponse.

Citation:

Sans trop prendre de risque, je peux dire : dans la liste d'initialisation du constructeur.

Je ne vois pas trop comment se servir de la liste initialisation dans ce cas. Par exemple, une classe que je vais appeler test.
Code:

1 2 3 4 5 class test{ public: test(void); int tab[4]; };
Code:

1 2 3 4 5 #include "test.h" test::test(void):tab(je mets quoi ici?) { }
Que dois-je mettre dans cette liste pour que le contenu du tableau soit 1, 8 , 6 , 2 par exemple?

Citation:

Depuis C++11, tu peux initialiser directement les données membres lors de la déclaration.

Malheureusement, je travaille avec VS2013 et son compilateur ne le permet pas, car j'obtiens le message suivant:

Citation:

impossible de spécifier un initialiseur explicite pour les tableaux

Citation:

Pour les tableaux qui ont une taille qui varie, tu peux utiliser std::vector. Si la taille est connue à la compilation

Ca n'est pas très pratique dans mon cas car mes tableaux me servent à composer des trames de longueur connues. La classe gérant le port de transmission possède des méthodes attendant des tableaux "classiques" d'octets.

J'ai lu que VS2013 supportait beaucoup de fonctionnalités de C++11 (mais pas toutes). ll faut peut être l'activer quelque part dans les options.
Tu peux essayer ce code C++11 :
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 // g++ -Wall -Wextra -Wconversion -Wsign-conversion -std=c++11 -pedantic -fopenmp main.cpp -o main && ./main #include <iostream> class test { private: static constexpr std::size_t m_size = 4; public: int tab[m_size] = { 0, 1, 2, 3 }; test() { } std::size_t size() const { return m_size; } }; int main() { test t; for (std::size_t i = 0; i < t.size(); ++i) { std::cout << t.tab[i] << std::endl; } return 0; }
Pour C++03, tu peux utiliser boost::array et faire une fonction qui retourne un tableau construit comme tu veux (pour l'appeler dans la liste d'initialisation en utilisant le constructeur par copie de boost::array) ; ou faire ta propre implémentation afin d'avoir un constructeur à utiliser dans la liste d'initialisation.

16/11/2014, 10h44
jackk

D'après microsoft, VS2013 supporte l'initialisation de membres non statiques.
Je suis également allé voir dans les propriétés du projet, et en particulier la partie compilateur, si on pouvait paramétrer la version de la norme utilisée. Apparemment non.

Le code que tu m'as fourni ne compile pas. La 1ère erreur générée est "Erreur 1 error C2143: erreur de syntaxe : absence de ';' avant 'size_t' ". A mon avis constepr n'est pas reconnu.

Si c'est constexpr qui bloque, essaye ce code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// g++ -Wall -Wextra -Wconversion -Wsign-conversion -std=c++11 -pedantic -fopenmp main.cpp -o main && ./main
 
#include <iostream>
 
 
class test
{
public:
	int tab[4] = { 0, 1, 2, 3 };
 
	std::size_t size() const { return sizeof(tab) / sizeof(tab[0]); }
};
 
int main()
{
	test t;
	for (std::size_t i = 0; i < t.size(); ++i)
	{
		std::cout << t.tab[i] << std::endl;
	}
 
	return 0;
}

16/11/2014, 18h48
jackk

Je retrouve l'erreur de départ pointant sur la définition du tableau

Citation:

Erreur 1 error C2536: 'test::test::tab' : impossible de spécifier un initialiseur explicite pour les tableaux

Citation:

Envoyé par jackk

Code:

1
2
3
4
5
#include "test.h"
 
test::test(void):tab(je mets quoi ici?)
{
}

:mrgreen: :mrgreen: :mrgreen: :mrgreen:

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
#include<cstring>
#include<iostream>
 
 
template<size_t size>
class Test {
public:
 
    friend std::ostream& operator << (std::ostream& os, Test& a) {
        if ((a.nb_elements > 0) && (a.int_array != NULL)) {
            os << "[" << a.int_array[0];
 
            for(size_t nb = 1; nb < a.nb_elements; ++nb) {
                os << ", " << a.int_array[nb];
            }
 
            os << "]";
        }
 
        return os;
    }
 
 
public:
 
    Test() : int_array( ((size != 0)? new int[size]: NULL) ), nb_elements(size) {
        if (int_array != NULL) {
            std::memset(int_array, 0, size);
        }
    }
 
    ~Test() {
        if (int_array != NULL) {
            delete[] int_array;
            int_array = NULL;
        }
    }
 
 
private: // or public:
    int* int_array;
    size_t nb_elements;
};
 
// ...
 
Test<5> a;
Test<6> b;
std::cout << a << std::endl << b << std::endl

Soit tu n'as pas activé C++11. Soit VS2013 est moisi... (troll)

Cela dit, si tu peux avoir C++11 :) Tu peux utiliser std::array (?)
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 // g++ -Wall -Wextra -Wconversion -Wsign-conversion -std=c++11 -pedantic -fopenmp main.cpp -o main && ./main #include <iostream> #include <array> class test { public: std::array<int, 4> tab; test() : tab({ 0, 1, 2, 3 }) { } // Si la liste d'initialisation est mal gérée (code non équivalent) : test() { tab = { 0, 1, 2, 3 }; } }; int main() { test t; for (std::size_t i = 0; i < t.tab.size(); ++i) { std::cout << t.tab[i] << std::endl; } return 0; }
L'avantage c'est que si C++11 n'est pas activer on aura une erreur sur std::array.
Sinon, il te reste plus qu'à utiliser boost::array ou faire ta propre implémentation.

Edit :
@foetus, je ne vois pas l'intérêt de ton code et encore moins l'utilisation de new [] et delete [] ici...

16/11/2014, 20h38
jackk

Citation:

Envoyé par foetus

:mrgreen: :mrgreen: :mrgreen: :mrgreen:

Je rappelle que l'on me proposait d'utiliser une liste d'initialisation dont je ne savais effectivement pas trop quoi faire.

Pour le reste, je ne vois pas en quoi le code que tu me propose apporte une solution à mon proplème qui est de définir un tableau la déclaration de la classe.
16/11/2014, 20h54
jackk

Ca passe avec std::array .

Pour les méthodes des classes qui attendent des tableaux classiques, je devrais pouvoir m'en sortir avec std::array;;data()

Merci pour tout
16/11/2014, 21h02
foetus

Citation:

Envoyé par Ehonn

Edit :
@foetus, je ne vois pas l'intérêt de ton code et encore moins l'utilisation de new [] et delete [] ici...

Si pour me mettre des -1, VIVE LE C++11 et il n'existe que le C++11 :lol: :lol:

Citation:

Envoyé par jackk

Je rappelle que l'on me proposait d'utiliser une liste d'initialisation dont je ne savais effectivement pas trop quoi faire.

Pour le reste, je ne vois pas en quoi le code que tu me propose apporte une solution à mon problème qui est de définir un tableau la déclaration de la classe.

Tu peux avoir un attribut étant un tableau crochet :mrgreen:
Mais c'est tout sauf flexible: tableau fixe, il faut connaître la taille (la mettre en attribut), faire attention si c'est un tableau de pointeurs et ... des recopies de partout (pour l'initialisation, pour la recopie, pour l'affectation, ...)
Sans parler du fait que tu ne peux pas faire d'initialisations paresseuses: là tu as 5 entiers, cela va encore :mrgreen:

Je te propose un pointeur avec une classe templatée, limite smart pointeur: cela améliore un peu les choses.

Ce n'est pas par rien que Ehonn s'époumone avec ces std::vector, std::array, ces listes {} C++11 voire même en passant par boost: c'te machine de guerre :mrgreen:
Ehonn ne t'as parlé des reserve et des std::swap :mrgreen:
16/11/2014, 21h30
Ehonn

Citation:

Envoyé par foetus

Si pour me mettre des -1, VIVE LE C++11 et il n'existe que le C++11 :lol: :lol:

std::vector existe en C++98 (et oui, en 2014 (bientôt 2015), utiliser C++11 (qui supporté par la majorité des compilateurs) n'est pas absurde) :roll:

Citation:

Envoyé par foetus

Tu peux avoir un attribut étant un tableau crochet :mrgreen:
Mais c'est tout sauf flexible: tableau fixe, il faut connaître la taille (la mettre en attribut), faire attention si c'est un tableau de pointeurs et ... des recopies de partout (pour l'initialisation, pour la recopie, pour l'affectation, ...)
Sans parler du fait que tu ne peux pas faire d'initialisations paresseuses: là tu as 5 entiers, cela va encore :mrgreen:

Je te propose un pointeur avec une classe templatée, limite smart pointeur: cela améliore un peu les choses.

Ce n'est pas par rien que Ehonn s'époumone avec ces std::vector, std::array, ces listes {} C++11 voire même en passant par boost: c'te machine de guerre :mrgreen:
Ehonn ne t'as parlé des reserve et des std::swap :mrgreen:

Mon code est simple et respecte la norme de C++11.
Ton code est beaucoup trop compliqué et beaucoup trop dangereux et ne répond pas au problème de base : pouvoir initialiser un tableau qui ait une donnée membre en tapant 1, 2, 8, 11 (ce qui n'est pas possible en une seule ligne avec la std de C++03).

Citation:

Envoyé par Ehonn

pouvoir initialiser un tableau qui ait une donnée membre en tapant 1, 2, 8, 11 (ce qui n'est pas possible en une seule ligne avec la std de C++03).

Même avec les variadic function :mrgreen:

Ou alors en fonction des besoins (si la taille est inférieure à 10), tu peux préparer 10 templates (comme je l'ai fait en passant la taille) avec un constructeur ayant autant d'entiers que la taille

Du style:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 template<1> class Test { Test(int a) { .... } int tab[1]; }; template<2> class Test { Test(int a, int b) { .... } int tab[2]; }; template<3> class Test { Test(int a, int b, int c) { .... } int tab[3]; }; template<4> class Test { Test(int a, int b, int c, int d) { .... } int tab[4]; }; /* ... */

16/11/2014, 21h58
Ehonn

Ce n'est pas une seule ligne (et je ne comprend pas vraiment comment le code règle le souci).
Mais oui on peut s'en sortir avec des variadic template (C++11 surtout).

On peut aussi surcharger l'operator ,, il y a un exemple de ~2003 sur hardware.fr par JoelF ^^
(mais bon c'est probablement overkill ici)