{

cout << "callStack:" << endl;

for (vector<string>::iterator it = callStack.begin(); it != callStack.end(); ++it)

cout << *it << endl;

cout << "END callStack" << endl;

{

virtual const char* what() const throw()

{

return "myexception::what()";

}

{

if (throw_int)

throw 1;

else

throw 'c';

{

switch (which)

{

case 0: throw 0; break;

case 1: throw myexception(); break;

default: throw 'c'; break;

}

{

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:

int i;

//default constructor

NoBaseNoMember() : i(0) {

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

}

//copy constructor

NoBaseNoMember(const NoBaseNoMember& other) : i(other.i) {

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

}

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

//assign

NoBaseNoMember& operator= (const NoBaseNoMember& rhs) {

this->i = rhs.i;

callStack.push_back("NoBaseNoMember::operator=");

return *this;

}

//destructor

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

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

static NoBaseNoMember create()

{

return NoBaseNoMember();

}

static NoBaseNoMember createNrvo()

{

NoBaseNoMember c;

return c;

}

/* it would be hard or impossible to do RVO for this function */

static NoBaseNoMember createNrvoHard(bool b = false)

{

//2 int constructors

NoBaseNoMember cf = NoBaseNoMember(0);

NoBaseNoMember ct = NoBaseNoMember(1);

return b ? ct : cf;

//2 int destructors

}

static void temporaryReference(NoBaseNoMember& temp)

{

temp.i = 0;

}

static void temporaryReferenceConst(const NoBaseNoMember& temp)

{

}

public:

int i;

explicit ExplicitCtor(int i) : i(i) {}

explicit ExplicitCtor(int i, int j) : i(i + j) {}

//TODO this makes no sense right, since it is not a ctor that takes a single arg?

//why does it compile without warning

//explicit void method(){}

//ERROR: only for constructors

{

public:

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

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

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

{

public:

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

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

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

{

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:

std::vector<int> v;

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

for (auto& i : list)

v.push_back(i);

}

InitializerListCtor(int before, std::initializer_list<int> list, int after) {

v.push_back(before + 1);

for (auto& i : list)

v.push_back(i);

v.push_back(after - 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:

Nested()

{

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

}

{

public:

/*

typedef int NESTED_INT;

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

{

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

//this->i=0;

//this->j=1;

//BAD

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

//to keep uniform style, always use list init

//ic=0;

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

//Base b;

//BAD

//compiles but infinite loop!

}

/*

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;

i = iStatic;

i = iConstStatic;

}

void constMethod() const;

void constMethod(int *&) const;

//return references

int& getRefIPublic() {return this->iPublic;}

const int& getPrivateConstRef() const {return this->iPrivate;}

//value cannot be changed

int& getPrivateRef() {return this->iPrivate;}

//value can be changed

//int& getPrivateRef() const {return this->iPrivate;}

//ERROR

//const method cannot return noncosnt reference!

//int* getPrivateAddress() const {return &this->iPrivate;}

//ERROR

//const method cannot return noncosnt pointer!

const int* getPrivateAddressConst() const {return &this->iPrivate;}

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

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

//virtual: decides on runtime based on object type

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

virtual Base* covariantReturn()

{

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

return new Base;

}

virtual void covariantArg(Base* b)

{

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

}

int i, j;

//int initialized_outside_ctor = 0;

//ERROR

//cannot initialize here

int iPublic;

int iAmbiguous;

int* is;

float fs4[4];

std::vector<int> vi;

mutable int mutableI;

//static mutable int staticMutableI;

//ERROR

//statics can be changed in const functions by default

/*

//#static

static void staticMethod();

//static void staticMethod() const;

//ERROR

//static cannot be const

static int iStatic;

//int iStatic;

//concflicts with static int

const static int iConstStatic = 0;

//OK

//because const static integral type

/*

const int iConstInit = 0;

//static int iStatic = 0;

//ERROR

//cannot initialize here unless const

//const static float fConstStatic = 0.0;

//ERROR

//non-integral type

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;