public:

int i;

std::string s;

public:

NoDefaultCtor(int i) : i(i) {}

int i;

public:

int i;

ExplicitDefaultCtor(){}

ExplicitDefaultCtor(int i) : i(i){}

public:

int i;

DefaultCopyAssignCtor() : i(0) {}

DefaultCopyAssignCtor(int i) : i(i) {}

public:

NoEquality() : i(0) {}

int i;

public:

std::vector<int> v;

/**

CtorFromCtor(int i) : v(1,i) {}

/**

CtorFromCtor(int i, int j) : CtorFromCtor(i) {

v.push_back(j);

}

public:

/**

DefaultKeyword() = default;

/**

DefaultKeyword(const DefaultKeyword&) = default;

/**

DefaultKeyword & operator=(const DefaultKeyword&) = default;

~DefaultKeyword() = default;

// ERROR: Not possible because the default constructor must take no arguments.

//DefaultKeyword(int i) = default;

// With the default keyword it is possible to have other

// constructors besides the Implicitly defined constructor.

DefaultKeyword(int i, std::string s) : i(i), s(s) {}

/**

//void f() = default;

int i;

std::string s;

public:

DeleteKeyword() = delete;

DeleteKeyword(int i) : i(i) {}

DeleteKeyword(const DeleteKeyword&) = delete;

DeleteKeyword & operator=(const DeleteKeyword&) = delete;

/**

//~DeleteKeyword() = delete;

/* It is possible to delete any function. */

void f() = delete;

int i;

public:

int i;

int j;

public:

int i;

int j;

UniformInitializationExplicitCtor() : i(0), j(0) {}

public:

int i;

int j;

UniformInitializationCtor2(int i, int j) : i(i), j(j+1) {}

bool operator==(const UniformInitializationCtor2& other) {return this->i == other.i && this->j == other.j;}

public:

int i;

int j;

UniformInitializationList(int i, int j) : i(i), j(j+1) {}

UniformInitializationList(std::initializer_list<int> list){

i = *(list.begin());

j = *(list.begin() + 1);

}

public:

NoBaseNoMember0 member0;

NoBaseNoMember1 member1;

MemberConstructorTest(){callStack.push_back("MemberConstructorTest::MemberConstructorTest()");}

~MemberConstructorTest(){callStack.push_back("MemberConstructorTest::~MemberConstructorTest()");}

void method(){callStack.push_back("MemberConstructorTest::method()");}

public:

Member(){callStack.push_back("Member::Member()");}

Member(int i){callStack.push_back("Member::Member(int)");}

~Member(){callStack.push_back("Member::~Member()");}

void method() {callStack.push_back("Member::method()");}

int i;

public:

/// Best to put typedefs on top of class so def will go for entire class.

typedef int NESTED_INT;

Base() : i(0), j(1) {

callStack.push_back("Base::Base()");

// BAD: same as list init, except if i is an object

// to keep uniform style, always use list init

//this->i=0;

//this->j=1;

// ERROR: ic is const. must be initialized in list initialization.

//ic=0;

// BAD: compiles but infinite loop!

//Base b;

}

/*

Base(int i, int j) : i(i), j(j) {

callStack.push_back("Base::Base(int, int)");

}

// ERROR: constructor cannot be virtual:

//virtual Base(float f){}

#if __cplusplus >= 201103L

/// C++11 initialize array/std containers in list initializtion.

Base(float f) : i(0), fs4{f,f,f,f}, vi{0,1,2,3} {

callStack.push_back("Base::Base(float)");

}

#endif

virtual ~Base() {

callStack.push_back("Base::~Base()");

}

void method() {

callStack.push_back("Base::method()");

int i = iAmbiguous;

}

void constMethod() const;

void constMethod(int *&) const;

void methodAmbiguous(){callStack.push_back("Base::methodAmbiguous()");}

// virtual: decides on runtime based on object type

// http://stackoverflow.com/questions/2391679/can-someone-explain-c-virtual-methods

virtual void virtualMethod(){callStack.push_back("Base::virtualMethod()");}

int i, j;

// ERROR: cannot initialize here.

//int initialized_outside_ctor = 0;

int iPublic;

int iAmbiguous;

int* is;

float fs4[4];

std::vector<int> vi;

mutable int mutableI;

// ERROR: statics can be changed in const functions by default.

//static mutable int staticMutableI;

/*

/*

const int iConstInit = 0;

// ERROR: non-integral type.

//const static float fConstStatic = 0.0;

const static Member member;

// OK: why ok?

const static Member member2;

//default constructor works

//const static NoBaseNoMember(1);

/*

class Nested {

public:

Nested() {

callStack.push_back("Base::Nested::Nested()");

int i = privateStaticInt;

//you have private access

}

Member m;

};

class Nested2 {

public:

Nested2() {

callStack.push_back("Base::Nested2::Nested2()");

}

Nested innerIn;

//inner one

::Nested innerOut;

//outter one

};

protected:

int iProtected;

void fProtected(){callStack.push_back("Base::fProtected()");}

private:

int iPrivate;

void fPrivate(){callStack.push_back("Base::fPrivate()");}

const static int privateStaticInt = 1;

typedef int PRIVATE_NESTED_INT;

public:

friend class FriendOfFriend;

Friend(int i) : i(i) {}

int getI(){return this->i;}

//this declaration says that `friendGetIPrivate(Base)` is a friend of this class.

//It will be defined outside the class.

friend int friendGetI(Friend f);

/* The same as friendGetI, but also defined inside the class. */

friend int friendGetIInnerDefine(Friend f) {

// ERROR: it is as if this were a friend external function, so there is no `this`.

//return this->i;

return f.i;

}

int getFriendI(FriendOfFriend f);

private:

int i;

void privateMethod(){};

// ERROR: this is a non-member function, so no `this`.

//return this->i;

return f.i;

public:

FriendOfFriend(int i) : i(i) {}

int getFriendI(Friend f){return f.i;}

void callFriendPrivateMethod(Friend f){f.privateMethod();}

private:

int i;

// ERROR: cant assign member in const func.

//this->i = 2;

// ERROR: cant call non const method inside const method!

// as that method could change the object

//this->member.method();

// ERROR: cant assign member of a member in const method.

//this->member.i = 1;

/*

this->mutableI = 1;

callStack.push_back("Base::constMethod()");

{

// ERROR: conversion from const Base* to Base*.

//Base* this2 = this;

const Base* this2const = this;

}

public:

BaseProtected(){callStack.push_back("BaseProtected::BaseProtected()");}

BaseProtected(int i){callStack.push_back("BaseProtected::BaseProtected(int)");}

~BaseProtected(){callStack.push_back("BaseProtected::~BaseProtected()");}

public:

BasePrivate(){callStack.push_back("BasePrivate::BasePrivate()");}

BasePrivate(int i){callStack.push_back("BasePrivate::BasePrivate(int)");}

~BasePrivate(){callStack.push_back("BasePrivate::~BasePrivate()");}

public Base,

// ERROR: duplicate.

//public Base,

// WARN: cannot use BasePrivate inside: ambiguous.

//public Derived,

protected BaseProtected,

private BasePrivate

{

public:

/*

Class() : i(0), z(1) {

callStack.push_back("Class::Class()");

}

Class(int i) : i(i), z(0) {

callStack.push_back("Class::Class(int)");

}

/*

Class(int i, int z) : Base(i,z), BaseProtected(i), BasePrivate(i), i(i), z(z) {

callStack.push_back("Class::Class(int, int)");

}

// WARN: BaseAbstract will be init after TODO ?

//Class() : BaseAbstract(), Base(i,z), BaseProtected(i), BasePrivate(i), i(i), z(z)

//try catch in case base constructor can throw exceptions

Class(int i, int j, int z) try : Base(i,j), i(i), z(z) {

callStack.push_back("Class::Class(int, int, int)");

}

catch(const std::exception &e) {

throw e;

}

Class(Member m) : m(m) {

// BAD: m constructor would be called, but this is useless since we have already called it!

// to construct it before.

// This is an application of initialization constructors.

//this->m = m;

callStack.push_back("Class::Class(Member)");

}

/*

Class(const Class& c) : i(c.i), z(c.z), m(c.m) {

callStack.push_back("Class::Class(Class)");

}

// Classes don't have constructors from base by default.

Class(const Base& b) : Base(b) {

callStack.push_back("Class::Class(Base)");

}

/*

~Class() { callStack.push_back("Class::~Class()"); }

// Called method overwriding.

void method() { callStack.push_back("Class::method()"); }

// OK.

template<class C=int>

void methodTemplate() {

callStack.push_back("Class::methodTemplate()");

}

int i;

int z;

Member m;

Nested nested;

//Base nested class visible from here

public:

// OK: you can override the Nested class from the Base also

class Nested{};

public:

int *is;

std::size_t n;

CopyAndSwap(std::size_t n, int val) : n(n) {

is = new int[n];

for (std::size_t i = 0; i < n; ++i) {

is[i] = val;

}

}

~CopyAndSwap(){

delete[] is;

}

CopyAndSwap& operator=(const CopyAndSwap& rhs) {

delete[] is;

is = new int[rhs.n];

return *this;

}

CopyAndSwap(const CopyAndSwap& other) {

}

public:

VisibleInnerIterable();

typedef std::vector<int> Iterable;

const Iterable& getIterable();

private:

Iterable iterable;

#if __cplusplus >= 201103L

/*

{

// As of C++11, classes can be defined inside functions!

// This matches the behaviour for structs in C.

{

class C {};

}

// Template classes however cannot be defined in functions.

// Just think what should the compiler do in this case?

{

//template<class T> class C {};

}

}

#endif

/*

{

/*

{

// To call the default constructor, use this syntax

{

callStack.clear();

NoBaseNoMember c; //default constructor was called!

std::vector<std::string> expectedCallStack = {

"NoBaseNoMember::NoBaseNoMember()",

};

assert(callStack == expectedCallStack);

}

/*

{

ImplicitDefaultCtor o;

if (o.i != 0)

// undefined behaviour.

std::cout << "ImplicitDefaultCtor undefined behaviour: o.i = " << o.i << std::endl;

// Defined behaviour because class:

assert(o.s == "");

// *however*, the following does value initialization,

// not the default constructor, and built-in members are indeed 0 initialized!

{

ImplicitDefaultCtor o = ImplicitDefaultCtor();

assert(o.i == 0);

}

}

{

// ERROR:

//NoDefaultCtor o;

// ERROR cannot be done because this class has not default constructors.

//NoDefaultCtor os[2];

// Implicit copy and assign are still defined:

NoDefaultCtor o(1);

NoDefaultCtor o2(o);

o = o2;

}

#if __cplusplus >= 201103L

/*

{

DefaultKeyword o;

// Undefined behaviour.

//assert(o.i == 0);

assert(o.s == std::string());

o = DefaultKeyword(1, "a");

assert(o.i == 1);

assert(o.s == "a");

}

/*

{

// ERROR: Explicitly deleted:

//DeleteKeyword o;

DeleteKeyword o(1);

// ERROR: Explicitly deleted:

//DeleteKeyword o2(o);

DeleteKeyword o2(2);

// ERROR: Explicitly deleted:

//o2 = o1;

}

#endif

}

/*

{

// Syntax with new.

{

// Base types.

{

int* is = new int[2]();

assert(is[0] == 0);

assert(is[1] == 0);

delete[] is;

}

// Works for structs.

{

struct T {int a;};

T *t = new T[1]();

assert(t[0].a == 0);

delete[] t;

}

// Works for objects.

//

// Note how the default constructor was called since `z == 1`.

{

{

Class *cs = new Class[1]();

assert(cs[0].i == 0);

assert(cs[0].z == 1);

delete[] cs;

}

}

// But only works with default constructors.

{

//Class *cs = new [1](1);

}

}

}

// # initialize built-in types

//

// http://stackoverflow.com/questions/5113365/do-built-in-types-have-default-constructors

//

// C++ adds new ways to initialize base types.

//

// Those are not however constructors.

//

// They probably just mimic constructor syntax to help blurr the distinction

// between built-in types and classes and make templates and typedefs work better.

{

// Parenthesis initialization

{

int i(1);

assert(i == 1);

}

{

// Most vexing parse.

//int i();

}

{

int i = int();

assert(i == 0);

}

#if __cplusplus >= 201103L

/*

{

// Built-int types

{