[C++] Type de {1,2,3}

Dev
1

Quel est le type exact d’un tableau sous la forme {1,2,3,4} ?
Je pensais que c’était un const *int ?

En fait, je me posais la question de pouvoir l’utiliser autrement que pour initialiser un tableau. Exemple avec une classe tableau, vecteur, liste, stack, etc…
Du style:

1. Stack S1; 2. Stack S1={1,2,3,4};
ou encore directement.

3. Stack S2={1,2,3,4};

Je peux bien sur faire un opérateur = qui prends un const *int, mais lors de l’écriture de la ligne 2 je me prends un « syntax error before { » à la compilation.
Quant au cas numéro 2, même avec un constructeur qui va bien il me demande d’initialiser S2 à l’aide d’un constructeur et non de ={…}. Les tableaux de la forme {…} seraient-ils réservés pour une utilisation à quelques cas seulement ?
J’ai cherché pas mal sur le net et dans mes bouquins, mais impossible de mettre la main là dessus.

Pour les ronchons, je précise que c’est à but purement pédagogique, je n’ai pas envie d’implémenter ça dans quoi que ce soit de réel. :stuck_out_tongue:

2

Ta classe Stack elle sort d’ou ? STL ? a bé oui suis je bete de la …

Ce qui est zarb c’est que d’aprés ça… Y a pas de operateur = tu as verifié qu’elle etait bien pleine ta stack ? Et sinon si tu fais stack S2 = …

Est ce que ca marche ?

Koubiak qui se fait un bon vieux Bob Dylan

3

Non ma classe Stack n’existe pas, c’est un exemple. C’est dans le cas où je voudrais créer un opérateur ou un constructeur qui utilise des tableaux sous la forme {1,2,3…}. Je me posais la question sur le type d’un tableau de cette forme et sur les possibilités de l’utiliser hors du contexte “int tab[]={1,2,3};”, avec une classe perso.

4

[quote name=‘Merlin’ date=’ 20 Nov 2004, 13:27’]Non ma classe Stack n’existe pas, c’est un exemple. C’est dans le cas où je voudrais créer un opérateur ou un constructeur qui utilise des tableaux sous la forme {1,2,3…}. Je me posais la question sur le type d’un tableau de cette forme et sur les possibilités de l’utiliser hors du contexte “int tab[]={1,2,3};”, avec une classe perso.
[right][post=“305207”]<{POST_SNAPBACK}>[/post][/right][/quote]

et const int[] ca marche pas ?

Koubiak

5

Nop j’ai fais un essai ça ne fonctionne pas. La classe se compile sans problème mais c’est au niveau de l’utilisation que ça ne passe pas (cf les messages d’erreur dans mon premier post) à la compil.

6

Je ne suis pas sûr d’avoir compris ce que tu voulais faire (surtout que la, je suis crevé), mais je peux confirmer qu’un tableau d’entier est bien du type int* (le const, je ne suis pas sûr, voire carrément contre).
Pour initialiser une classe depuis un opérateur =, ce n’est pas une surcharge du = qu’il faut écrire, mais un constructeur par copie, qui prendra donc en paramètre un objet du même type que lui, donc un objet de type stack dans ton cas.

En écrivant ce constructeur, tu pourras alors faire un truc du genre strack s2 = stack1. Ok c’est vrai que du coup tu ne peux pas écrire directement un truc du genre strack s2 = {1, 2, 3}, vu que la surchage de l’opérateur = ne peut pas servir de constructeur. Ah moins que peut être, tu le mettes en static et que tu lui demande de retourner une instance de stack, mais je ne garantis rien.

7

Oui je sais qu’un tableau d’entier est de type int * :stuck_out_tongue:
En revanche ce que je voulais c’est le cas particulier où le tableau est déclaré en dur dans le code source sous la forme {1,2,3,4,…}. Si ce truc-là a un type, il est const de toute façon vu que l’on ne peut pas y toucher.

Pour le constructeur par copie pas de soucis non plus je sais bien comment ça marche. Ce que je cherche à faire c’est le cas bien particulier où je pourrais écrire:

stack s1={1,2,3};

D’un côté je veux qu’il utilise le fait que lorsqu’un constructeur n’a qu’un seul argument on peut l’utiliser sous la forme type var=val.

Par exemple si je fais une classe Array avec comme constructeur:

Array(int size);

Je peux déclarer un tableau de 10 sous la forme:

Array t1(10); ou Array t2=10;
De l’autre je veux détourner l’utilisation des {} pour mes propres besoin (enfin besoin de curiosité surtout).

Mais plus j’y réfléchis et plus je me dis que ce n’est pas possible. Car un tableau sous la forme {1,2,3,4} est une facilité du compilo pour créer un agrégat. Si je voulais faire 4 tableaux chacun d’une taille différente je pourrais écrire :

Array tab[]={10,11,12,13};

Et le compilo utiliserait le constructeur Array(int size) pour me faire 4 tableaux de tailles respectives 10,11,12 et 13. Mais ici je voudrais en détourner l’utilisation pour écrire quelque chose sous la forme:

Array tab={10,11,12,13}

pour qu’il me crée un tableau à 4 cases, initialisés à 10,11,12 et 13. Ce qui n’est pas la même chose et je ne sais pas si c’est possible… :stuck_out_tongue:

8

Je crois que ce que tu veux faire n’est pas possible. L’initialisation au travers d’une suite entre accolades n’est qu’une simplicité d’écriture apportée par le C et seulement valable lors de la déclaration et non pas à la volée lors d’une affectation.

En revanche il y a une GROSSE confusion que j’ai relevé dans au moins deux threads : dire qu’un tableau d’entiers est du type int * est une bêtise.
Ce n’est pas parce qu’une variable déclarée soit en int * tab soit en int tab[] s’utilise de la même façon grâce à l’opérateur [] qu’il faut faire le raccourci cité et en déduire que c’est le même type. Que nenni.

Pour vous en convaincre, déclarez dans un fichier file1.cc la variable suivante :

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

puis dans un second fichier (file2.cc) le code suivant :

[code]#include

#define MAX 3

// D’après ce que vous dites, je peux considérer que le tableau déclaré dans l’autre fichier est de type int *
extern int * tab;

using namespace std;

int main(void)
{
       cout << « coucou » << endl;

       for(int i=0; i<MAX; i++)
       {
               cout << tab[i] << endl;
       }
       return( 0 );
}[/code]

Compilez ces deux fichiers et linker puis déroulez l’application résultante :stuck_out_tongue:

9

Yep après avoir retourné le problème dans tous les sens, je suis d’accord avec toi ce n’est pas possible.

[quote name=‹ Moktar › date=’ 23 Nov 2004, 16:21’]En revanche il y a une GROSSE confusion que j’ai relevé dans au moins deux threads : dire qu’un tableau d’entiers est du type int * est une bêtise.
Ce n’est pas parce qu’une variable déclarée soit en int * tab soit en int tab[] s’utilise de la même façon grâce à l’opérateur qu’il faut faire le raccourci cité et en déduire que c’est le même type. Que nenni.[/quote]

Oui effectivement meaculpa, j’ai fait la confusion dans la description de mon problème, int (*)[] ce n’est pas la même chose que int *. En revanche ça se convertit bien:

[code]/* file1.cc */
int tab={1,2,3}

/* file2.cc */
extern int tab;
int tab2=tab;
…
/ Et utiliser tab2 partout comme tu veux */[/code]

Mais ce n’est pas tout à fait la même chose :stuck_out_tongue: