Discussion :

[abiraa]

comment est ce que je peux déclarer un tableau d'objets?

[toxcct]

comment est ce que je peux déclarer un tableau d'objets?

comment un tableau de l'importe quel type natif :

Code :

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

1
2
3
4
5
class CMonType {
    //...
};
 
CMonType montab[50];    //un tableau de 50 CMonType

penser a utiliser la STL aussi

Code :

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

1
2
 
std::vector<CMonType> montabDynamique;

[abiraa]

bonjour,
lorsque je mets
nom_class nom_tableau[2];
à la compilation un message d'erreur mentionne :no matching function for call to `slot::slot()'
comment je peux le corriger?
merci

[toxcct]

tu définis bien un constructeur par défaut ? (ta classe, c'est bien slot ?)

[abiraa]

bonjour,
justement, c'est quoi un constructeur par défaut?
moi j'ai défini, deux constructeurs et ma classe est bien slot.
merci

[abiraa]

çà y est j'ai défini un constructeur par défaut, les deux constructeurs que j'ai sont:
slot();
slot(int an_id);
lorsque je compile mon programme, il accepte mon tableau:
slot mes_slots[2];
mais lorsque j'applique le deuxième constructeur à chaque élément du tableau :
mes_slots[0] = slot(2);
mes_slots[1] = slot(1);
j'ai une erreur, me disant expected construtor or destructor, or type conversion before =
merci de me répondre.

[millie]

tu définis bien un constructeur par défaut ? (ta classe, c'est bien slot ?)

Ajouter artificiellement un constructeur par défaut pour faire compiler le programme, ça reste pas super

Tu peux jetter un oeil à l'utilisation de std::vector en tant que tableau :
http://c.developpez.com/faq/cpp/?pag...UCTEUR_tableau

[toxcct]

Ajouter artificiellement un constructeur par défaut pour faire compiler le programme, ça reste pas super

Tu peux jetter un oeil à l'utilisation de std::vector en tant que tableau :
http://c.developpez.com/faq/cpp/?pag...UCTEUR_tableau

millie, je n'ajoute pas un constructeur "pour faire compiler", mais parce qu'il en faut un...
prends l'exemple des algorithmes stl. si tu utilise std::sort(), il faut implémenter les operators <, == et = (je crois). est ce que dans ce cas tu implémente ces opérateurs pour corriger un pb de compilation ? ou parce qu'il les faut ?

[millie]

C'est un cas un peu différent ici.

Il est possible d'avoir des classes sans constructeur par défaut, et en définir un peut ne pas avoir de sens (après, ça peut dépendre de la spécification de la classe, mais peut être que dans son cas, ça a un sens. Mais comme il n'avait pas vraiment précisé)

Normalement, si tu veux programmer proprement, il faudrait toujours définir le constructeur par recopie et l'opérateur = pour garder la cohérence des données à coup sûr.

Si tu te retrouves à vouloir trier des données dans ta classe, il est évident qu'il est nécessaire d'avoir une fonction de comparaison (et donc un operateur de comparaison pour plus de logique ).

[toxcct]

si tu ne définis pas de constructeurs pr ta classe, le compilateur t'en génere un vide par défaut.

si par contre tu définis un ou plusieurs autres constructeurs, mais pas de ctor par défaut, ce constructeur n'existera pas sur ta classe, et certaines opérations implicites du compilateur pourront ne pas compiler en conséquence...

[millie]

si tu ne définis pas de constructeurs pr ta classe, le compilateur t'en génere un vide par défaut.

C'est bien pour ça qu'il faut le faire car c'est très dangereux, notamment sur le bout de code là :

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
class Buffer {
 private:
  int * _tab;
 public:
  Buffer(int taille) {
    if(taille<=0)
      ...
    _tab = new int[taille];
  }
 
  int lire(int i)
  {
   return _tab[i];
  }
 
  ~Buffer()
  {
    delete _tab;
    _tab = NULL;
  }
};
 
Buffer* mafonction()
{
 Buffer b(4);
 Buffer * autre = new Buffer(b);
 return autre;
}
 
void autrefonction()
{
  Buffer * b = mafonction();
  b->lire(1) ------ seg fault
}

EDIT : Je croyais que tu parlais du constructeur par recopie

[abiraa]

mais pour moi même quand j'ajoute un constructeur par défaut çà ne marche pas lorsque je veux initialiser les éléments du tableau.

[Luc Hermitte]

Pourquoi vous ne lui donnez pas la solution simple ?

Code :

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

1
2
3
std::vector<slot> tab;
tab.push_back( slot(1, "toto") );
tab.push_back( slot(42, "titi") );

Mais cela nécessite que les objets soient copiables.
Sinon, il faut sortir les pointeurs.

Code :

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

1
2
3
std::vector<slot *> tab;
tab.push_back( new slot(1, "toto") );
tab.push_back( new slot(42, "titi") );

(Sinon ... il faut faire des new de placement si tout tes slots occupent la même place en mémoire -- ie. par d'héritage avec ajout de membre. Mais là, c'est super compliqué pour rien)

[loufoque]

Tu peux 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
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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
#include <bitset>
#include <iostream>
 
#include <boost/type_traits.hpp>
 
template<typename T, size_t N>
class not_initialised;
 
template<typename T, size_t N>
class not_initialised_array
{
public:
    not_initialised<T, N> operator[](size_t i)
    {
        return not_initialised<T, N>(*this, i);
    }
 
    ~not_initialised_array()
    {
        for(size_t i=0; i<N; i++)
            if(init.test(i))
                reinterpret_cast<T*>(&data[i])->~T();
    }
 
private:
    typename boost::aligned_storage<
        sizeof(T),
        boost::alignment_of<T>::value
    >::type
    data[N];
 
    std::bitset<N> init;
 
    friend class not_initialised<T, N>;
};
 
template<typename T, size_t N>
class not_initialised
{
public:
 
    not_initialised(not_initialised_array<T, N>& array_, size_t i_) : array(array_), i(i_) {}
 
    T& operator=(const T& t)
    {
        if(array.init.test(i))
        {
            return *reinterpret_cast<T*>(&array.data[i]) = t;
        }
 
        array.init.set(i);
        new(&array.data[i]) T(t);
 
        return *reinterpret_cast<T*>(&array.data[i]);
    }
 
    operator T&()
    {
        if(!array.init.test(i))
            throw 42;
 
        return *reinterpret_cast<T*>(&array.data[i]);
    }
 
private:
    not_initialised_array<T, N>& array;
    size_t i;
};
 
struct slot
{
    int a;
 
    slot(int a_) : a(a_)
    {
    }
 
    friend std::ostream& operator<<(std::ostream& os, const slot& s)
    {
        os << s.a;
        return os;
    }
};
 
int main()
{
    try
    {
        not_initialised_array<slot, 50> tab;
 
        tab[5] = slot(2);
        std::cout << tab[5] << std::endl; // affiche 2
        std::cout << tab[10] << std::endl; // lève une exception
    }
    catch(...)
    {
        std::cerr << "Exception non gérée" << std::endl;
    }
}

[Garulfo]

Vous ne vous êtes pas dit que c'est peut-être une question dans un cours et que donc il/elle (désolé abiraa... je ne suis sur de rien ^_^) n'a pas le choix d'utiliser un tableau ?

[abiraa]

bonjour,
çà ne marche pas lorsque j'utilise:
std::vector<slot > tab;
tab.push_back( new slot(1, "toto") );
tab.push_back( new slot(42, "titi") );
ni quand j'utilise les pointeurs:
std::vector<slot *> tab;
tab.push_back( new slot(1, "toto") );
tab.push_back( new slot(42, "titi") );
il y a un problème de constructeur,
lorsque j'écris: slot(42, "titi")çà veut dire que j'utilise le deuxième constructeur que j'ai mentionné avec le nom de l'élémebt du tableau "titi?"

[millie]

Vous ne vous êtes pas dit que c'est peut-être une question dans un cours et que donc il/elle (désolé abiraa... je ne suis sur de rien ^_^) n'a pas le choix d'utiliser un tableau ?

Nous ne sommes pas ici pour résoudre les exercices des autres.

[millie]

lorsque j'écris: slot(42, "titi")çà veut dire que j'utilise le deuxième constructeur que j'ai mentionné avec le nom de l'élémebt du tableau "titi?"

Ca veut dire que tu as définis un constructeur dont le prototype est du genre :

Code :

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

slot::slot(int, char*);

A priori, ce n'était pas le cas... Je ne comprend pas pourquoi tu mets des "titi" maintenant ?

[abiraa]

j'ai utilisé un tableau de pointeurs avec la solution suivante:
slot** T = new slot[10];
for(i=0;i<10;i++){
T[i] = new Objet(i);
}

où slot est ma classe, mais çà ne marche pas non plus:
cannot convert `slot*' to `slot**' in initialization

[millie]

j'ai utilisé un tableau de pointeurs avec la solution suivante:
slot** T = new slot[10];

Tu pourrais penser à la balise code

Ici, c'est normal, tu cherches à créer un tableau de tableau. Sauf que chaque tableau est en fait un slot. Il faudrait écrire :

Code :

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

1
2
3
4
slot ** tab = new slot * [10];
for(i=0;i<10;i++){
tab[i] = new slot(cequetuveux);
}

Et pense bien à tout détuire