operator [] sur liste d'initialisation

Version imprimable

12/04/2015, 12h48
MrPchoun

operator [] sur liste d'initialisation
Bonjour,

J'aimerais remplacer le code suivant :
Code:

1 2 std::vector<unsigned> vector = {5,6,7,8}; unsigned a = vector[3]; // a = 8
Par celui là :

Code:

unsigned a = {5,6,7,8}[3]; // a = 8

Mais mon compilateur me fait des embrouilles (Excess elements in scalar initializer). Est ce un problème de syntaxe ou est ce que le C++ n'admet tout simplement pas cette possibilité ?

Merci pour vos réponses :)
12/04/2015, 17h52
the Hound

Le compilateur n'a aucune idée de ce qu'est {5, 6, 7, 8}. Il faut le préciser :

Code:

unsigned a = (std::vector<unsigned> {5, 6, 7, 8})[3];
12/04/2015, 19h07
MrPchoun

Moui.. M'enfin moi jvoulais éviter d'avoir à créer un vector en fait :)
12/04/2015, 19h09
Iradrille

Citation:

Envoyé par the Hound

Le compilateur n'a aucune idée de ce qu'est {5, 6, 7, 8}.

Le compilo sait très bien que c'est une std::initializer_list<int>.

Mais les std::initializer_list<int> ne fournissent que des itérateurs pour un accès séquentiel, donc pas d'operator[] et pas de *(begin() + 3) non plus.
12/04/2015, 19h34
the Hound

Citation:

Envoyé par Iradrille

Le compilo sait très bien que c'est une std::initializer_list<int>.

J'ai simplifié au possible ;)
Mais ça n'a pas de valeur "sémantique" valide dans ce contexte : la std::initializer_list<> est conçue pour l'initialisation d'un objet, et pour rien d'autre.
12/04/2015, 19h41
MrPchoun

Citation:

Mais les std::initializer_list<int> ne fournissent que des itérateurs pour un accès séquentiel, donc pas d'operator[] et pas de *(begin() + 3) non plus.

Ça m'embête tout ça.. Y a-t-il espoir qu'une prochaine version du C++ offre de telles possibilités ?
13/04/2015, 00h34
jo_link_noir

Citation:

Envoyé par Iradrille

Mais les std::initializer_list<int> ne fournissent que des itérateurs pour un accès séquentiel, donc pas d'operator[] et pas de *(begin() + 3) non plus.

Les itérateurs fournit par std::initializer_list sont des pointeurs. Donc *(begin() + 3) est valide.
13/04/2015, 09h12
Iradrille
Vu que initializer_list ne fourni pas d'operator[], je supposais que la manière dont était stockée les éléments n'était pas garanti et dépendait de l'implémentation (peut être implémenté comme un vector ou une list, ou autre).
Et donc que les itérateurs fournis ne permettaient pas un accès aléatoire.

Mais après lecture de la doc, les éléments sont forcément consécutifs en mémoire (style vector ou array) et les itérateurs fournis permettent un accès aléatoire (ce sont de simple pointeurs).

Dans ce cas pourquoi est-ce-que
Code:

1 2 3 4 5 unsigned a = {5, 6, 7, 8}[3]; // ou auto il = {5, 6, 7, 8}; unsigned b = il[3];
N'est pas valide ?

Alors que
Code:

1 2 3 auto il = {5, 6, 7, 8}; unsigned a = std::begin(il)[3]; unsigned b = *(std::begin(il) + 3);
L'est ?

Quelle est la raison pour ne pas fournir d'operator[] ?

C'est dangereux ce genre d'incohérence je trouve, si on veut le faire en 1 ligne on se retrouve face à une UB (je crois ? {5, 6, 7, 8} est détruit au retour de begin ?)
Code:

1 2 unsigned a = *(std::begin({5, 6, 7, 8}) + 3); unsigned b = std::begin({5, 6, 7, 8})[3];
13/04/2015, 09h27
ternel

Une valeur temporaire n'est détruite qu'à la fin de l'évaluation d'une expression complète, pas d'une expression locale.

Pour le reste je ne sais pas trop, je n'ai jamais essayé de telles choses.

Ce qui fait une magnifique transition pour ma question suivante !

Je me suis appuyé sur le dernier code d'Iradrille, mais le code ne compile pas. Pourquoi ? (Calling a private constructor of class 'std::type_info')
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 template <typename...Ts> struct Test { void function(unsigned i) { std::cout<<(std::begin({typeid(Ts)...})[i]).name(); } }; int main() { Test<int,char,bool> test; test.function(2); return 0; }

Parce que tu essaies de copier des type_info, c'est un type non copiable.

Tu peux par contre copier le nom.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
#include <typeinfo>
 
struct Foo {};
 
template <typename...Ts>
struct Test {
    void function(unsigned i) {
        std::cout << std::begin({typeid(Ts).name()...})[i];
    }
};
 
int main() {
    Test<int, char, bool, Foo> test;
    test.function(2);
    std::cout << '\n';
    test.function(3);
 
    return 0;
}

Résultat (gcc)

Code:

1
2
b
3Foo

13/04/2015, 21h01
MrPchoun

Habile.. Merci !! :)