Je sais que je peux initialiser des données comme ça.

int array[3] = { 1, 2, 3 };

Ou même

int array[2][2] = { {1, 2}, {3, 4} };

Je peux aussi le faire avec std::vector

std::vector<int> A = { 1, 2, 3 };

Disons que je veux écrire ma propre classe:

class my_class
{
     std::vector< int > A;
     public:
     //pseudo code
           my_class(*x) { store x in A;} //with x={ {1, 2}, {3, 4} }
     // do something
};

Est-il possible d'écrire un tel constructeur et comment est-ce possible? Quelle est cette déclaration

{{1, 2}, {3, 4}} fait réellement?

Je trouve toujours simplement que vous pouvez initialiser les données de cette manière, mais jamais ce qu'elles font précisément.

6
Markus 23 mai 2018 à 16:07

3 réponses

Meilleure réponse

Il s’appelle initialisation de liste et vous avez besoin d’un std :: initilizer_list constructeur, que ce soit réalisé dans votre my_class.

Voir (Démo en direct)

#include <iostream>
#include <vector>
#include <initializer_list> // std::initializer_list

class my_class
{
    std::vector<int> A;
public:
    // std::initilizer_list constructor 
    my_class(const std::initializer_list<int> v) : A(v) {}    

    friend std::ostream& operator<<(std::ostream& out, const my_class& obj) /* noexcept */;
};

std::ostream& operator<<(std::ostream& out, const my_class& obj) /* noexcept */
{
    for(const int it: obj.A) out << it << " ";
    return out;
}

int main()
{
    my_class obj = {1,2,3,4};  // now possible
    std::cout << obj << std::endl;
    return 0;
}
10
JeJo 19 mai 2019 à 21:43

Vous pouvez utiliser initializer_list dans le constructeur pour avoir une telle option.

struct X {
    X() = default;
    X(const X&) = default;
};

struct Q {
    Q() = default;
    Q(Q const&) = default;
    Q(std::initializer_list<Q>) {}
};

int main() {
  X x;
  X x2 = X { x }; // copy-constructor (not aggregate initialization)
  Q q;
  Q q2 = Q { q }; // initializer-list constructor (not copy constructor)
}
3
Sumit Jha 23 mai 2018 à 13:14

comment est-ce possible?

Si vous avez une liste d'initialiseurs.

#include  <initializer_­list> // use std::initializer_list template
my_class(const std::initializer_list<int>& v) : A(v) {}

Que fait réellement cette déclaration "{{1, 2}, {3, 4}}"?

Cela s'appelle list-initialization

Si l'initialiseur est une braced-init-list (sans parenthèses) ou est = braced-init-list , l'objet ou la référence est initialisé par liste .

3
Joseph D. 23 mai 2018 à 14:28