Discussion :

[Theinfrarougegp]

Bonjour .
Je sais qu'on peut déclaré une variable comme ça:
int var (3);

Mais est-ce qu'une variable peut se déclarer comme en Java:
int var = 3;
Help-me svp
Je n'ai pas encore écrit mon premier programme j'ai juste
commencé à suivre un cours

[Bousk]

Salut,

tu as perdu plus de temps à écrire ce post qu'à réaliser le test.
Heureusement cette syntaxe existe, et est bien plus utilisé que la première.

ps: http://fr.wikibooks.org/wiki/Fran%C3%A7ais/%C3%89_et_ER

[bacelar]

Heu, oui mais non.

Le code entre les deux n'est pas strictement identique pour les type "complexes" (utilisation de l'opérateur = versus utilisation d'un constructeur).

Le C++11 homogénéise la chose avec l'utilisation systématique des accolades " int var{0};". Avec de l'habitude, cette nouvelle notation devient bien plus lisible.

Ce n'est donc pas une question si idiote.

[Bousk]

Le code entre les deux n'est pas strictement identique pour les type "complexes" (utilisation de l'opérateur = versus utilisation d'un constructeur).

Observe le code compilé et tu verras que (tous?) les compilateurs sont assez intelligents depuis plusieurs années pour transformer tout ça de manière optimisé quelle que soit l'écriture que tu choisis.

[JolyLoic]

Observe le code compilé et tu verras que (tous?) les compilateurs sont assez intelligents depuis plusieurs années pour transformer tout ça de manière optimisé quelle que soit l'écriture que tu choisis.

Il y a pourtant une différence, et dans certains cas, la syntaxe avec le = ne marchera pas (c'est lié aux constructeurs explicites, je ne vais pas entrer dans les détails, c'est hors de propos pour débuter), même si dans la plupart des cas, c'est équivalent.

[Neckara]

Bonjour,

Le C++11 homogénéise la chose avec l'utilisation systématique des accolades " int var{0};". Avec de l'habitude, cette nouvelle notation devient bien plus lisible.

Attention, si tu fais MaClasse{0} et MaClasse(0), ce ne sera pas le même constructeur qui sera appelé (si ta classe possède les deux constructeurs).

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
#include <iostream>
#include <initializer_list>
#include <string>
 
class Foo
{
    public :
        Foo(int i){ std::cout << "normal" << std::endl; }
        Foo(int i, int j){ std::cout << "normal" << std::endl; }
        Foo(std::initializer_list<int> l){ std::cout << "init" << std::endl; }
        Foo(std::string, std::string){ std::cout << "normal s" << std::endl; }
};
 
 
int main(void)
{
    Foo(5);
    Foo{5};
    Foo(1,2);
    Foo{1,2};
    // Foo(1,2,5); pas ok
    Foo(std::string("e"), std::string("r"));
    Foo{std::string("e"), std::string("r")};
}

normal
init
normal
init
normal s
normal s

Observe le code compilé et tu verras que (tous?) les compilateurs sont assez intelligents depuis plusieurs années pour transformer tout ça de manière optimisé quelle que soit l'écriture que tu choisis.

Je ne suis même pas sûr que ce soit une histoire de transformation ou d'optimisation.
Il me semble qu'aux yeux de la norme les deux notations sont totalement équivalentes (pour l'initialisation bien évidement et aux contraintes explicite près).