[C++] Differenza inizializzazione, most vexing parse, ed altre varie particolarità

[biowep]

Salve,
Dato che sto studiando il C++ ed ogni volta che cerco delle informazioni su una particolare sintassi o risorsa delle librerie standard finisco in un vortice di innumerevoli schede (del browser) aperte con pagine di stack overflow, dove si discutono casi particolari di sintassi astruse ed ambigue che producono risultati completamente differenti da come ci si aspetterebbe. Ecco, dato che ormai sono giorni che sto studiando il linguaggio in questione e che ogni volta che devo fare una determinata cosa, semplicissima ci sono molti modi con sottili differenze per ottenerla.

Pensiamo ad un programma C++ complesso in cui sia presente:

• operator overloading
• cast impliciti (basati sull'overload degli operatori)
• oggetti trattati come se fossero delle funzioni (functors)
• chiamate implicite al costruttore predefinito (non sempre chiaramente individuabili)
• chiamate implicite al copy constructor predefinito (non sempre chiaramente individuabili)
• inizializzazione e assegnamenti con tante sintassi diverse (da C++11 anche la uniform syntax initialization)
• varie ambiguità tra cui vexing parse ed incertezza sulla funzione da chiamare (se un oggetto può essere implicitamente convertito a più di un tipo del dato che la funzione prende in input)
• method overriding
• ...

Data una combinazione più o meno complessa di queste cose (che alcuni considerano libertà ma per me sono problema) volevo chiedere a chi normalmente programma in C++ per lavoro (confrontandosi con codice reale scritto da altre persone) quanto spesso ci si imbatte in cose del genere? Io sto usando il linguaggio per scrivere un'applicazione multi piattaforma che ho in mente ma sto facendo tutto da solo quindi non so bene quali siano le good practices.

Se voletem gentilmente spiegatemi dettagliatamente la differenza tra le seguenti sintassi, non sono ancora riuscito a capire a fondo (anche perché in italiano non si trova quasi niente e l'inglese lo comprendo ma non al 100% e non vorrei studiare 2 cose contemporaneate ).

#include <iostream>
using namespace std;

class Test {
public:
	int v;
	Test(int val) : v(val) {}
};


int main() {
	int valore = 12345;
	Test a(valore);
	Test b{valore};
	Test c = valore;
	Test d = {valore};
	Test e = Test(valore);
	Test f = a;

	cout
	<< a.v << "\n"
	<< b.v << "\n"
	<< c.v << "\n"
	<< d.v << "\n"
	<< e.v << "\n"
	<< f.v;
}

[vendettaaaaa]

Purtroppo lavoro con C# e sebbene le mie (semplici) app personali le scriva con C++, c'è poco C++ e tanto Qt nel mio codice, quindi sono un po' arrugginito. Cmq quando studiavo il linguaggio avevo scritto questo codice per capire meglio costruttori e assegnazioni varie:

class TC
{
private:
int i = 0;
static int count;
int whoAmI = ++count;
public:
TC() { cout << "Building a default TC! I'm number " << whoAmI << endl; }
explicit TC(int ii) : i(ii) { cout << "Building a TC with an int! I'm number " << whoAmI << endl; }
TC(const TC& a) : i(a.i) { cout << "Copying a TC! I'm number " << whoAmI << endl; }
TC(TC&& a) : i(std::move(a.i)) { cout << "Moving a TC! I'm number " << whoAmI << endl; }
~TC() { --count; cout << "Destroying a TC! I'm number " << whoAmI << endl; }
TC& operator=(const TC& a)
{
if (this != &a)
{
cout << "Copying a TC, number " << a.whoAmI << ", with operator= ! I'm number " << whoAmI << endl;
i = a.i;
}
return *this;
}
TC& operator=(TC&& a)
{
cout << "Moving a TC, number " << a.whoAmI << ", with operator= ! I'm number " << whoAmI << endl;
std::swap(i, a.i);
return *this;
}
};
int TC::count = 0;
TC get_TC(int ii) { return TC(ii); }

int main()
{
// Test - More tests on copy/move constructors, default and deleted constructors, initializer lists
cout << "////////////////////////////////////////////////////" << endl;
cout << "Test - Copy or move? Let's see!" << endl << endl;
#define DO_AND_PRINT(x) cout << #x << " produces the following:" << endl; x
DO_AND_PRINT(TC tc1(1));
system("pause"); cout << endl;
DO_AND_PRINT(TC tc2(tc1));
system("pause"); cout << endl;
DO_AND_PRINT(TC tc3);
system("pause"); cout << endl;
DO_AND_PRINT(tc3 = tc2);
system("pause"); cout << endl;
DO_AND_PRINT(TC tc4(get_TC(2)));
system("pause"); cout << endl;
DO_AND_PRINT(TC tc5);
system("pause"); cout << endl;
DO_AND_PRINT(tc5 = get_TC(3));
system("pause"); cout << endl;
DO_AND_PRINT(TC tc6(std::move(tc1)));
system("pause"); cout << endl;
DO_AND_PRINT(tc6 = std::move(tc2));
system("pause"); cout << endl;
DO_AND_PRINT(TC& tc7 = tc6);
system("pause"); cout << endl;
DO_AND_PRINT(TC&& tc8 = TC(4));
system("pause"); cout << endl;
DO_AND_PRINT(tc8 = TC(4));
system("pause"); cout << endl;
DO_AND_PRINT(TC&& tc9 = std::move(tc7));
system("pause"); cout << endl;
DO_AND_PRINT(tc9 = std::move(tc8));
system("pause"); cout << endl;
#undef DO_AND_PRINT
}
return 0;
}

Aggiungi tu gli header che servono.

[biowep]

Grazie tante, molto utile
Bisogna solo togliere la graffa prima dell'ultima istruzione.

EDIT: ho trovato un'altra cosa interessante. Slicing problem.

#include <iostream>
using namespace std;

class A {
public:
	int a;
	A(int a) : a(a) {}
};
class B : public A {
public:
	int b;
	B(int a, int b) : A(a), b(b) {}
};
int main() {
	B b1(5,6);
	B b2(7,8);
	A& a_ref = b2;
	a_ref = b1;
	cout <<  dynamic_cast<B&>(a_ref).a << "\n" << dynamic_cast<B&>(a_ref).b;
}

[vendettaaaaa]

Non compila

[biowep]

#include <iostream>
using namespace std;

class A {
public:
	int a;
	A(int a) : a(a) {}
	virtual ~A() {}
};
class B : public A {
public:
	int b;
	B(int a, int b) : A(a), b(b) {}
};
int main() {
	B b1(5,6);
	B b2(7,8);
	A& a_ref = b2;
	a_ref = b1;
	cout <<  dynamic_cast<B&>(a_ref).a << "\n" << dynamic_cast<B&>(a_ref).b;
}

A non era polimorfico, qualunque cosa voglia dire.
EDIT:
Ecco un altro problema del C++. Non capisco perché tutti i metodi non siano virtual di default.

[tomminno]

Originariamente inviato da biowep

EDIT:
Ecco un altro problema del C++. Non capisco perché tutti i metodi non siano virtual di default.

Semplicemente performance.
Un metodo virtuale richiede l'accesso alla vtable e l'intervento del branch target predictor (in sostanza la chiamata ad un metodo virtuale è simile ad uno switch). E se il branch predictor sbaglia, devi svuotare la pipeline della CPU e ricominciare.

[biowep]

Però mediamente si definiscono più metodi virtuali. Non vedo il motivo per cui il comportamento predefinito non debba essere quello come la maggior parte dei linguaggi ad oggetti più evoluti

[vendettaaaaa]

Originariamente inviato da biowep

Però mediamente si definiscono più metodi virtuali. Non vedo il motivo per cui il comportamento predefinito non debba essere quello come la maggior parte dei linguaggi ad oggetti più evoluti

Perchè il C++ è un linguaggio di programmazione che supporta non solo il paradigma ad oggetti ma anche quello della programmazione generica, è pensato per portare un alto livello di astrazione mantenendo le performance più alte possibili. Quindi "tutto è un oggetto", e "tutti i metodi sono virtuali" non fanno parte della filosofia del C++.

[gbhu]

La programmazione ad oggetti non implica necessariamente l'utilizzo del polimorfismo. Uno potrebbe anche realizzare un programma facendo solo uso dell'incapsulazione e non utilizzare l'ereditarietà.
E anche utilizzando l'ereditarietà non è detto che si debba per forza avere il polimorfismo.
Comunque per farlo compilare basta aggiungere ad A un distruttore virtual: virtual ~A() {}.
Tra l'altro se si fa uso del polimorfismo è cosa buona e giusta mettere i distruttori virtual nelle classi base onde evitare problemi di memory leak.