#include <iostream>
using namespace std;struct B
{virtual void print(){}//想要使用 dynamic_cast ，基类中必须有虚函数
};
struct D : B
{void print(){}
};int fun(){}int main()
{int i = static_cast<int>(3.14); //i == 3const int j = 10;int *pj = const_cast<int*>(&j);//int *pj = (int*)(&j);     //等同于上面*pj = 20;//虽然 *pj的地址和 j 的地址是一样的，但是值却不一样。cout<<*pj<<endl;    //20cout<<j<<endl;      //10
B *b;dynamic_cast<D*>(b);typedef void (*FunPtr)();reinterpret_cast<FunPtr>(&fun);     //尽量避免使用
}

#include <iostream>
using namespace std;struct B
{virtual void print() const{cout<<"base print()"<<endl;}
};
struct D : B
{void print() const{cout<<"derived print()"<<endl;}int id;  //如果没有此句，执行将正确，因为基类对象和子类对象长度相同
};int fun(const B array[],int size)
{for(int i = 0;i<size;++i){array[i].print();}
}int main()
{B barray[5];fun(barray,5);D darray[5];fun(darray,5);
}

#include <iostream>
using namespace std;class A
{public:A(int i):id(i){}A& operator++(){this->id += 1;return *this;}//返回值为 const ，以避免 a++++这种形式//因为第二个 operator++ 所改变的对象是第一个 operator++ 返回的对象//最终结果其实也只是累加了一次，a++++ 也还是相当于 a++，这是违反直觉的const A operator++(int){A a = *this;this->id += 1;return a;}int id;
};
int main()
{A a(3);cout<<++a.id<<endl; //++++a;   也是允许的，但 a++++ 不允许。cout<<a.id<<endl;cout<<a++.id<<endl;cout<<a.id<<endl;
}

#include <iostream>using namespace std;
class User
{public:void * operator new(size_t size){std::cout<<"size: "<<size<<std::endl;}void * operator new(size_t size,std::string str){std::cout<<"size: "<<size <<"\nname: " << str<< std::endl;}int id;
};int main()
{User* user1 = new User;User* user2 = new ("JIM")User;void *pi = operator new(sizeof(int));int i = 3;int *p = &i;pi = p;cout<<*(int*)pi<<endl;
}

#include <iostream>
#include <stdexcept>void exception_fun()
{throw std::runtime_error("runtime_error");
}void fun()
{int *pi = new int[10000];std::cout<<pi<<std::endl;try{exception_fun();    //如果此处抛出异常而未处理，则无法执行 delete 语句，造成内存泄漏。
    }catch(std::runtime_error& error){delete pi;throw;}delete pi;
}main()
{for(;;){try { fun(); } catch(std::runtime_error& error) { }}
}

#include <iostream>
#include <stdexcept>void exception_fun()
{throw std::runtime_error("runtime_error");
}void fun()
{int *pi = new int[10000];std::auto_ptr<int> ap(pi);    //用 auto_ptr 包装一下std::cout<<pi<<std::endl;exception_fun();
}main()
{for(;;){try { fun(); } catch(std::runtime_error& error) { }}
}

#include <iostream>
#include <string>
#include <stdexcept>class B
{public:B(const int userid_,const std::string& username_ = "",const std::string address_ = ""):userid(userid_),username(0),address(0){username = new std::string(username_);throw std::runtime_error("runtime_error");  //构造函数里抛出异常的话，由于对象没有构造完成，不会执行析构函数address = new std::string(address_);}~B()    //此例中不会执行,会导致内存泄漏
        {delete username;delete address;std::cout<<"~B()"<<std::endl;}private:int userid;std::string* username;std::string* address;
};main()
{try { B b(1); } catch(std::runtime_error& error) { }
}

#include <iostream>struct T
{T(){pi = new int;std::cout<<"T()"<<std::endl;}void init(){throw("init() throw");}~T(){std::cout<<"~T() begin"<<std::endl;throw("~T() throw");delete pi;std::cout<<"~T() end"<<std::endl;}int *pi;
};void fun()
{try{T t;t.init();}catch(...){}//下面也会引发 terminate/*try{int *p2 = new int[1000000000000L];}catch(std::bad_alloc&){std::cout<<"bad_alloc"<<std::endl;}*/
}void terminate_handler()
{std::cout<<"my terminate_handler()"<<std::endl;
}int main()
{std::set_terminate(terminate_handler);fun();
}

 1 #include <iostream>
 2
 3 void fun1(void)
 4 {
 5     int i = 3;
 6     throw i;
 7 }
 8 void fun2(void)
 9 {
10     static int i = 10;
11     int *pi = &i;
12     throw pi; //pi指向的对象是静态的，所以才能抛出指针
13 }
14
15 main()
16 {
17     try{
18         fun1();
19     }catch(int d)
20     {
21         std::cout<<d<<std::endl;
22     }
23     try{
24         fun2();
25     } catch(const void* v)
26     {
27         std::cout<<*(int*)v<<std::endl;
28     }
29 }

 1 #include <iostream>
 2 #include <stdexcept>
 3
 4 class B
 5 {
 6     public:
 7         B(int id_):id(id_){}
 8         B(const B& b){id = b.id;std::cout<<"copy"<<std::endl;}
 9         int id;
10 };
11
12 void fun(void)
13 {
14     static B b(3);  //这里是静态对象
15     throw &b;   //只有该对象是静态对象或全局对象时，才能以指针形式抛出
16 }
17 main()
18 {
19     try{
20         fun();
21     }catch(B* b)    //这里以指针形式接收
22     {
23         std::cout<<b->id<<std::endl;    //输出3
24     }
25 }

#include <iostream>
#include <stdexcept>class B
{public:B(){}B(const B& b){std::cout<<"B copy"<<std::endl;}virtual void print(void){std::cout<<"print():B"<<std::endl;}
};class D : public B
{public:D():B(){}D(const D& d){std::cout<<"D copy"<<std::endl;}virtual void print(void){std::cout<<"print():D"<<std::endl;}
};void fun(void)
{D d;throw d;
}
main()
{try{fun();}catch(B b) //注意这里
    {b.print();}
}

#include <iostream>void fun(void) throw(int,double);    //必须这样声明，而不能是 void fun(void);void fun(void) throw(int,double)    //说明可能抛出 int 和 double 异常
{int i = 3;throw i;
}main()
{try{fun();}catch(int d){std::cout<<d<<std::endl;}
}

#include <iostream>using namespace std;struct B
{B(int id_):id(id_){}int id;
};const B operator+(const B& b1,const B& b2)
{return B(b1.id + b2.id);
}//const B operator+(const B& b1,int i)    //如果重载此方法，就不会产生临时对象了
//{
//  return B(b1.id + i);
//}
int main()
{B b1(3),b2(7);B b3 = b1+ b2;B b4 = b1 + 6;    //会把 6 先转换成B对象，产生临时对象
}

#include <iostream>class B
{public:B(int id_):id(id_){}B& operator+=(const B& b){id +=  b.id;return *this;}int print_id(){std::cout<<id<<std::endl;}private:int id;
};B operator+(const B& b1,const B& b2)    //不用声明为 B 的 friend 函数,而且只需要维护 operator+= 即可。
{return const_cast<B&>(b1) += b2;    //这里要去掉b1的const属性，才能带入operator+= 中的 this 中
}int main()
{B b1(3),b2(7),b3(100);(b1+b2).print_id(); //10    这里进行 operator+ 操作，会改变 b1 的值，这个不应该吧b1.print_id();      //10b3+=b1;b3.print_id();      //110
}

#include <iostream>struct B1 { virtual void fun1(){} int id;};
struct B2 { virtual void fun2(){} };
struct B3 { virtual void fun3(){} };
struct D : virtual B1, virtual B2, virtual B3 {virtual void fun(){}  void fun1(){}  void fun2(){}   void fun3(){}};int main()
{std::cout<<sizeof(B1)<<std::endl;   //8std::cout<<sizeof(B2)<<std::endl;   //4std::cout<<sizeof(B3)<<std::endl;   //4std::cout<<sizeof(D)<<std::endl;    //16
}//D 中只包含了三个 vptr ，D和B1共享了一个。

#include <iostream>
#include <list>
#include <string>using namespace std;class B
{public:B(string str):value(str){}virtual ostream& print(ostream& s) const = 0;protected:string value;
};class D1 : public B
{public:D1(int id_):B("protect value"),id(id_){}    //子类构造函数中，要先调用基类构造函数初始化基类ostream& print(ostream& s) const{cout<<value<<"\t"<<id;;return s;}  //如果基类虚函数是 const 方法，则这里也必须使用 const 修饰private:int id;
};class D2 : public B
{public:D2(int id_):B("protect value"),id(id_){}    //子类构造函数中，要先调用基类构造函数初始化基类ostream& print(ostream& s) const{cout<<value<<"\t"<<id;return s;}private:int id;
};ostream& operator<<(ostream& s,const B& b)
{return b.print(s);
}int main()
{list<B*> lt;D1 d1(1);D2 d2(2);lt.push_back(&d1);lt.push_back(&d2);list<B*>::iterator it = lt.begin();while(it != lt.end()){cout<<*(*it)<<endl;     //D1   D2it++;}
}

#include <iostream>
#include <string>using namespace std;class B1    //禁止对象产生于 heap 中
{public:B1(){cout<<"B1"<<endl;};private:void* operator new(size_t size);void* operator new[](size_t size);void operator delete(void* ptr);void operator delete[](void* ptr);
};class B2    //要求对象产生于 heap 中
{public:B2(){cout<<"B2"<<endl;};void destroy(){delete this;}　　//模拟的析构函数private:~B2(){}
};
int main()
{//B1* b1  = new B1; //Error!
    B1 b1;//B2 b2;    //ErrorB2* b2 = new B2;b2->destroy();
}