class Foo {
public:
    Foo(){
       bar = 42;
       printf("Foo()\n");
    }
 
    Foo(int) {
       buzz = 196;
       Foo();
       printf("Foo(int); %i %i", bar, buzz);
    }
 
private:
    int bar;
    int buzz;
};
 
int main() {
    Foo foo(411);
}

printf("Foo(int); %i %i", bar, buzz); //Foo(int); <undefined> 196

~Foo() { 
    printf("~Foo()\n");
}

Foo(int) {
    buzz = 196;
    new (this) Foo(); //here be dragons
    printf("Foo(int); %i %i", bar, buzz);
}

#include <iostream>
#include <string>
#include <sstream>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <list>
 
double diffclock(clock_t clock1,clock_t clock2){
	double diffticks = clock1 - clock2;
	return (diffticks) / CLOCKS_PER_SEC;
}
 
template <typename T>
class List {
public:
    List():first(nullptr), last(nullptr){}
 
    bool empty() const {
        return first == nullptr;
    }
 
    bool add(T data) {
        Node* newNode = new Node(data);
        if (first == nullptr) {
            last = first = newNode;
        } else {
            last->next = newNode;
            newNode->prev = last;
            newNode->next = nullptr;
            last = newNode;
        }
        return true;
    }
 
    bool remove(T data) {
        Node* temp = first;
        while (temp && temp->data != data)
            temp = temp->next;
 
        if (!temp) return false;
        if (temp == first) {
            Node* newFirst = first->next;
            delete first;
            if (newFirst) newFirst->prev = nullptr;
            first = newFirst;
        } else if (temp == last) {
            Node* newLast = last->prev;
            delete last;
            if (newLast) newLast->next = nullptr;
            last = newLast;
        } else {
            Node* left = temp->prev;
            Node* right = temp->next;
            delete temp;
            left->next = right;
            right->prev = left;
        }
        return true;
    }
private:
    struct Node {
        Node(T dataRhs):data(dataRhs), prev(nullptr), next(nullptr){}
        T data;
        Node* prev;
        Node* next;
    };
 
    Node* first;
    Node* last;
};
 
template <typename T>
class Vector {
public:
    Vector():ptr(nullptr), index(0), maxSize(0){}
 
    bool empty() const {
        return index == 0;
    }
 
    bool reset(int newSize) {
        delete[] ptr;
        ptr = new T[newSize];
        maxSize = newSize;
        return true;
    }
 
    bool add(T data) {
        if (index == maxSize) return false;
        ptr[index++] = data;
        return true;
    }
 
    bool remove(T data) {
        int remIndex = -1;
        for (int i = 0; i < maxSize; ++i) {
            if (ptr[i] == data)  {
                remIndex = i;
                break;
            };
        }
        if (remIndex == -1) return false;
 
        memmove(&ptr[remIndex], &ptr[remIndex + 1], maxSize - remIndex);
        --index;
        return true;
    }
private:
    T* ptr;
    int index;
    int maxSize;
};
 
const int SIZE = 81000;
 
template <typename T>
void eraseContainer(T& container) {
    for (int i = 0; i < SIZE; ++i)
        container.remove(i);
}
 
template <typename T>
void eraseContainer(std::vector<T>& vec) {
    for (int i = 0; i < SIZE; ++i) {
        auto iter = std::find(vec.begin(), vec.end(), i);
        vec.erase(iter);
    }
}
 
double stdVecTime = 0.0;
double stdListTime = 0.0;
double customVecTime = 0.0;
double customListTime = 0.0;
 
void test() {
    std::vector<int> vecStd;
    vecStd.reserve(SIZE);
    for (int i = 0; i < SIZE; ++i)
        vecStd.push_back(i);
 
    std::random_shuffle(vecStd.begin(), vecStd.end());
 
    using namespace std;
    std::list<int> listStd;
    for (int i = 0; i < SIZE; ++i)
        listStd.push_back(vecStd[i]);
 
    Vector<int> vecCustom;
    vecCustom.reset(SIZE);
    for (int i = 0; i < SIZE; ++i) 
        vecCustom.add(vecStd[i]);
 
    List<int> listCustom;
    for (int i = 0; i < SIZE; ++i)
        listCustom.add(vecStd[i]);
 
    clock_t beginStdVec = clock();
    eraseContainer(vecStd);
    clock_t endStdVec = clock();
    stdVecTime+= double(diffclock(endStdVec,beginStdVec));
	if(!vecStd.empty()) printf("Bug in std vector test\n");
 
    clock_t beginStdList = clock();
    eraseContainer(listStd);
    clock_t endStdList = clock();
    stdListTime += double(diffclock(endStdList,beginStdList));
    if(!listStd.empty()) printf("Bug in std list test\n");   
 
    clock_t beginVec = clock();
    eraseContainer(vecCustom);
    clock_t endVec = clock();
    customVecTime += double(diffclock(endVec,beginVec)) ;
	if(!vecCustom.empty()) printf("Bug in custom vector test\n");
 
    clock_t beginList = clock();
    eraseContainer(listCustom);
    clock_t endList = clock();
    customListTime += double(diffclock(endList,beginList));
    if(!listCustom.empty()) printf("Bug in custom list test\n");
}
 
int main(int argc, const char * argv[]) {
    const double testTimes = 1.0;
    srand((unsigned)time(0));
    for (int i = 0; i < testTimes; ++i)
        test();
 
    std::cout << "Std vec time:" << stdVecTime / testTimes << std::endl;
    std::cout << "Std list time:" << stdListTime / testTimes << std::endl;
    std::cout << "Custom vec time:" << customVecTime / testTimes << std::endl;
    std::cout << "Custom list time:" << customListTime / testTimes<< std::endl;
 
    return 0;
}

#include <iostream>  
//all results are saved in ::Value (for type) and ::value (for value)  
 
//gives the smallest in ts... 
template<int n, int... ts> 
struct Min { 
	static const int value = n < Min<ts...>::value ? n : Min<ts...>::value; 
}; 
 
template <int n>
struct Min<n> { 
	static const int value = n; 
};   
 
//holder structure
template<int... vs> struct StaticArray {};   
 
//concatenates v... and u... into an StaticArray 
template<typename T1, typename T2>
struct Concat{}; 
 
template<int...v, int...u> 
struct Concat<StaticArray<v...>, StaticArray<u...>> { 
	typedef StaticArray<v..., u...> Value; 
};   
 
//gives the index of "v" in args... 
 
template<int v, int a, int... args> 
struct IndexOf { 
	static const int value = v == a ? 0 : 1 + IndexOf<v, args...>::value; 
};   
 
template <int v, int a> 
struct IndexOf<v, a> { 
	static const int value = v == a ? 0 : -1;   
};  
 
 //remove element with index "n" from args... 
 
template<int n, int a, int... args> 
struct RemoveNth {
	typedef StaticArray<a> headValue;
        typedef typename RemoveNth< (n - 1), args...>::Value Tail; 
	typedef typename Concat<headValue, Tail>::Value Value; 
};   
 
template<int a> 
struct RemoveNth<0, a> { 
	typedef StaticArray<> headValue; 
	typedef StaticArray<> Value; 
};   
 
template<int a, int... args> 
struct RemoveNth<0, a, args...> { 
	typedef StaticArray<args...> headValue; 
	typedef StaticArray<args...> Value; 
};   
 
//sorts args... 
template<typename T1> 
struct Sort{}; 
 
template<int... args> 
struct Sort <StaticArray<args...>> {
	//get he min value 
	typedef Min<args...> min; 
	//and its index 
	typedef IndexOf<min::value, args...> index; 
	//remove the min from the list
	typedef typename RemoveNth<index::value, args...>::Value Filtered; 
	//call recursively for the others 
	typedef typename Sort<Filtered>::Value TailSorted; 
	//concat min with the others
        typedef typename Concat<StaticArray<min::value>, TailSorted>::Value Value; 
}; 
 
template<int n> 
struct Sort<StaticArray<n>> { 
	typedef Min<n> min;
        typedef StaticArray<n> Value; 
};  
 
template<> 
struct Sort<StaticArray<>> { 
	typedef StaticArray<> Value; 
};   
 
void printStaticArray(StaticArray<>){ }   
 
template<int v1, int...vs> 
void printStaticArray(StaticArray<v1, vs...> m) { 
	std::cout << v1<< " "; printStaticArray(StaticArray<vs...>()); 
}   
 
int main (int argc, const char * argv[]) { 
	printStaticArray(Sort<StaticArray<196, -1, 0, 309, -42, 411>>::Value()); 
	return 0;
}