std::cout << "callStack:" << std::endl;

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

std::cout << *it << std::endl;

std::cout << "END callStack" << std::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

// ERROR: only for constructors.

//explicit void method(){}

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:

/// 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;

i = iStatic;

i = iConstStatic;

}

void constMethod() const;

void constMethod(int *&) const;

//return references

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

/// Value cannot be changed.

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

/// Value can be changed

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

// ERROR: const method cannot return noncosnt reference!

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

// ERROR: const method cannot return noncosnt pointer!

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

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

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()");}

virtual Base* covariantReturn() {

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

return new Base;

}

virtual void covariantArg(Base* b) {

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

}

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;

/*

//#static

static void staticMethod();

// ERROR: static cannot be const.

//static void staticMethod() const;

static int iStatic;

// Concflicts with static int.

//int iStatic;

// OK: because const static integral type

const static int iConstStatic = 0;

/*

const int iConstInit = 0;

// ERROR: cannot initialize here unless const.

//static int iStatic = 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`.