C++:运算符重载、string类重写、数据类型转换、->操作符重载、virtual继承、virtual函数、typeid
1.运算符重载
谁调用了成员函数，谁就是当前对象。在C++中运算符操作就是函数。含有const或者引用成员变量时，构造函数要人为的初始化。Int i=9; cout<<i.相当于operator<<(cout,i);cout是ostream的单例，只能有这一个实例，因此在重载<<时必须要用引用。如有一个类person，实现<<的代码如下：ostream & operator<< （ostream &os,const person &p）const {os<<p.id<<p.name;return os;} >>代码如下：istream & operator>> (istream &ism, person &p){ism>>p.id>>p.name; return ism;} 引用的名字不能和变量相同，如int &i=i是不行的。若返回函数值为引用类型，表示可以出现在＝左边，程序可以修改其值，函数返回值为const类型，可以防止其出现在＝的左边。当构造函数只有一个成员变量时，可以用＝直接赋值，如person p=100.表示p(100)。当实现2目运算符时，最好写成友元函数，以-为例，如果 100-一个对象时，如果是类的成员函数，100无法调用-这个操作符。当在1目运算符时，最好写成内部成员函数。前++和后++操作符是通过（int）中的哑元函数来区别的。前++由于是返回对象本身本身的引用，所以可以放在＝的左边。后++由于是返回一个中间值来保存old值，所以不能放在=的左边。类的友元函数是指在类的整个函数中都可以访问类对象的私有成员。不允许重载的操作符： ：： 。 .* ?: sizeof typeid .在做运算符重载时，要注意以下：不允许对基本数据类型重载，如int + int 不可以定义为 int *int 。不允许创造运算符。不能违反语法定义的形式，如不能将%定义为一元运算符，单目运算符不可以变成双目运算符。 只能定义为类成员函数的运算符（包含有＝的运算符，如＝＝ ！＝ ）＝ 《＝等包含＝的操作符和 []下标运算符）。强制类型转换是间接的。编译器将＝赋值运算符已经写好了，当类里面有指针之类的操作时，＝运算符的重载要自己写。赋值运算符重写的步骤：判断是否与自己相等，若是自己，则返回*this (if(this==传过来变量的地址))，则表示是自己，此时返回自己。释放原有空间 。申请新的空间。复制数据，返回当前对象。 当函数返回 *this时，而函数不是引用时，此时返回的仍是一个临时值，只有加上了&,才真正意义上的返回了自己。不仅函数可以是友元，一个类也可以是另一个类的友元。不可以返回一个局部变量的引用，如果返回了一个局部变量的引用，会产生一个临时对象，这个临时对象会调用copy构造函数在调用函数中开辟一块内存存这个临时变量（虽然你可能不会调用它，但并不影响它的存在）。若返回为输入进来的变量的引用，则返回与输入是同一回事。
2.string类重写
#include <iostream>
using namespace std;
class CStr
{
public:
CStr(){ps=NULL;len=0;}
CStr(char *ps);//构造函数
CStr(const CStr &s);//COPY构造函数
~CStr();//析构函数
CStr &operator=(const CStr &s);//重载=
void show(){cout<<ps<<endl;}
int getlength()const {return len;}
friend void strcpy(CStr &s1,const CStr &s2);
private:
char *ps;
int len;
};
void strcpy(CStr &s1,const CStr &s2)//完成两个字符的copy
{
if(s1.ps==s2.ps) return;
if (s1.ps) {delete []s1.ps;}
s1.len=s2.getlength();
s1.ps=new char[s1.len+1];
int i;
for (i=0;i<s1.len;i++)
{*(s1.ps+i)=*(s2.ps+i);}
*(s1.ps+s1.len)=0;
}
CStr &CStr::operator=(const CStr &s)
{
int i;
if (s.ps==ps)
{return *this;}
else
{
len=s.getlength();
ps=new char[len+1];
for (i=0;i<len;i++)
{*(ps+i)=*(s.ps+i);}
*(ps+len)=0;
return *this;
}
}
CStr::CStr(const CStr &s)
{
int i;
if (s.ps==NULL)
{ps=NULL;len=0;}
else
{
len=s.getlength();
ps=new char[len+1];
for (i=0;i<len;i++)
{*(ps+i)=*(s.ps+i);}
*(ps+len)=0;
}
}
CStr::~CStr()
{
if(len) delete[] ps;
}
CStr::CStr(char *p)
{
int i=0;
if (p==NULL)
{ps=NULL;len=0;}
else
{
len=0;
while (*(p+len)!=0) len++;
ps=new char[len+1];
for (i=0;i<len;i++)
{*(ps+i)=*(p+i);} *(ps+len)=0;
}
}
int main()
{
CStr s1("abcdefg");
CStr s2(s1);
CStr s3="12345";
strcpy(s3,s1);
//s1=s3;
s1.show();
s2.show();
s3.show();
return 0;
}
3.数据类型转换
#include <iostream>
using namespace std;
class CDouble
{
double d1,d2;
public:
CDouble(const CDouble &d){d1=d.d1;d2=d.d2;cout<<"copy CDouble"<<endl;}
CDouble(double d1=0.0,double d2=0.0):d1(d1),d2(d2) {cout<<"CDouble"<<endl;}
void show(){cout<<d1<<' '<<d2<<endl;}
~CDouble(){cout<<"~CDouble()"<<endl;}
//operator CInteger(){return d;}//CDouble->CInteger
};
class CInteger
{
int x,y;
public:
CInteger(const CInteger &i){x=i.x;y=i.y;cout<<"copy CInteger"<<endl;}
CInteger(int x=0,int y=0):x(x),y(y) {cout<<"CInteger"<<endl;}
CInteger(CDouble d){cout<<"CInteger(CDouble d)"<<endl;}//CDouble->CInteger 前面加explicit，此函数必须要显式调用，不能进行自动转换，隐匿调用。
operator CDouble(){cout<<"operator CDouble()"<<endl;return x;}//CInteger->CDouble
void show(){cout<<x<<' '<<y<<endl;}
~CInteger(){cout<<"~CInteger()"<<endl;}
};
int main()
{ CDouble d(1.4,2.3);
CInteger i(3,4);
//d=i;
i=d;
d.show();
i.show();
return 0;
}
/*结果为：
单独d=i的结果：
CDouble
CInteger
operator CDouble()
CDouble
~CDouble()
~CInteger
~CDouble
由此可见，在转换的时候中间有一个临时变量来转换的。*/
当类CDouble中有向CInteger转换的函数时，而CInteger中也有向CDouble类型转换的函数时，会产生歧义操作，所以不要出现这种情况。
另外一个例子：
#include <iostream>
using namespace std;
class Double{
double d;
public:
Double(double d=0.0):d(d){}
};
class Integer{
int x;
public:
//构造函数也有类型转换功能
Integer(int x=0):x(x){}
friend ostream& operator<<(ostream&o,const Integer&i){
return o << i.x;
}
friend istream& operator>>(istream&is,Integer&i){
return is >> i.x;
}
//类型转换运算符
operator int(){
cout << "operator int()" << endl;
return x;
}
operator Double(){
cout << "operator Double()" << endl;
return x;//因为Double类中只有一个数据变量，所以才可以返回x.事实上上将x的值转化成了d.
}
};
void fa(Double d){}
void fb(Integer i){}
int main()
{
Integer i = 100;
int x = (int)i;
x = int(i);
x = i.operator int();
x = i;
Double d;
d = i;
fa(i);
i = 200;
int y = 300;
i = y;
fb(y);
}
4.->操作符重载
#include <iostream>
using namespace std;
class emp{
static int id;
public:
static void show(){cout<<id++<<endl;}
};
int emp::id=0;
class emplist{
emp *es[100];
int sz;
public:
emplist():sz(0){}//:sz()表示sz=0这种方法在windows下不能用。
void add(emp *e){es[sz]=e;sz++;}
friend class pointer;//一个类也可以是另外一个类的友元类。
};
class pointer{
emplist &e;
int index;
public:
pointer(emplist &e):e(e),index(0) {}
emp* operator-> (){return e.es[index];}//由于->操作的重载会导致两个->，所以要返回一个指针，实际得到的数据是返回指针的->。
bool operator++(){//判断是否越界
if (index<0 || index>=e.sz) return false;
index++;
return true;
}
bool operator++(int){//后++与前++是一样的，因为只是判断越界与否
return operator++();
}
emp &operator*(){return *e.es[index];}//取值
};
//将类pointer直接当作指针emp对象的来用
int main()
{
emp e1;
emp e2;
emplist e;
e.add(&e1);
e.add(&e2);
pointer p(e);
p->show();
p++;
p->show();//等同于(*p).show();
return 0;
}
附 ：new和delete的重载函数形式为：
void *operator new(size_t sz) {cout<<"operator new"<<endl;return data;}
void operator delete(void *p){cout<<"operator delete"<<endl;}
这只是函数形式，具体内容还要自己增加。若new中没有给分配内存空间，则会出现段错误。
5.virtual继承
#include <iostream>
using namespace std;
class goods{
double price;
public:
goods(double price=0):price(price) {cout<<"goods construct"<<endl;}
double getprice(){cout<<"goods price:"<<price<<endl;return price;}
~goods(){cout<<"goods deconstruct"<<endl;}
};
class camera: virtual public goods{
double price;
public:
camera(double price=0):price(price),goods(price) {cout<<"camera construct"<<endl;}
//double getprice(){cout<<"camera price:"<<price<<endl;return price;}
~camera(){cout<<"camera deconstruct"<<endl;}
};
//虽然camera是virtual继承goods的，但是也可以给它传值，virtual继承是为了给上一层调用都用的，如果光是camera和goods之间，是没有什么作用的，virtual并不会发挥它的作用。
class mp3: virtual public goods{
double price;
public:
mp3(double price=0):price(price) {cout<<"mp3 construct"<<endl;}
//double getprice(){cout<<"mp3 price:"<<price<<endl;return price;}
~mp3(){cout<<"mp3 deconstruct"<<endl;}
};
class phone: virtual public goods{
double price;
public:
phone(double price=0):price(price) {cout<<"phone construct"<<endl;}
//double getprice(){cout<<"phone price:"<<price<<endl;return price;}
~phone(){cout<<"phone deconstruct"<<endl;}
};
class cellphone:public camera,public mp3,public phone{
//mp3 m1;camera c1;phone p1;
double price;
public://在构造函数时，先按基于类顺序构造，再按成员变量来构造。
cellphone(double p1=0,double p2=0,double p3=0):camera(p1),
mp3(p2),phone(p3)//,goods(p1+p2+p3)
{cout<<"cellphone construct"<<endl;}
//double getprice(){double ptemp;
//ptemp=c1.getprice()+m1.getprice()+p1.getprice();
//cout<<"phone price:"<<ptemp<<endl;return ptemp;}
~cellphone(){cout<<"cellphone deconstruct"<<endl;}
};
int main()
{
cellphone cp(100,200,300);
//对于cellphone来说，goods的price由cellphone的构造函数直接决定，与camera、mp3、phone无关系。
camera c1(20);
c1.getprice();
cp.getprice();//当用虚函数继承以后，cp.camera::getprice()＝cp.getprice()。因为goods类只有一份。
return 0;
}
//如果任何一个camera、mp3、phone没有virtual继承，则cellphone中有两份goods，在调用的时候会有歧义。系统无法分辨。
名字隐藏是指子类重新实现了父类中函数，名字隐藏只要是函数名字相同就可以实现名字隐藏，与函数的参数列表及返回值无关。
当private继承父类时，父类的东西是继承下来了，只是不能用。当有父类时，子类的构造过程：分配内存空间，递归的构造父类，构造成员变量，调用构造函数，构造成员变量，调用构造函数。
子类不会继承父类的构造函数，析构函数，及赋值运算符等。当父类中有相同名字的函数时，在子类中就将父类中的函数隐藏起来了，除非调用父类：：将它调出来用。名字隐藏与函数的参数列表，返回值没关系，只要函数名字相同就可以。
当从父类private 继承下来的函数时，在外部不能调用，如果要调用，要重新写一个public函数就可以了（名字不能和父类的相同，名字相同会出现段错误，在此函数中调用私有函数）。多继承构造顺序：先按继承顺序，再按成员顺序。若继承三个，有成员三个，则调用构造函数6次，析构函数6次。
当有继承和组合两种组合成员时，优先组合，因为继承容易使数据不稳定。
Virtual继承不存在函数隐藏问题，它是直接override.
类的多态应用在指针和引用上面，调用的函数取决于指针，当有态呈现时，取决于指向的对象。前者是在编译的时候决定的，后者是在运行时候决定。如果子类中的参数表和父类中的不同，则不是覆盖，而和父类中继承来的函数形成重载关系。用引用时，引用必须初始化，一旦初始化，后面不能再强制类型转换，（就算是强制类型转换，也没有作用）。含有纯虚函数的类为抽象类，抽象类不能定义对象，如果子类中没有实现纯虚函数，则子类也有抽象类，抽象类除了不能定义对象，在其它方面使用和其它类一样。如果一个类中只有纯虚函数，此类为接口类。动态绑定的实现是通过虚函数表vtable实现的。只要函数中有虚函数（哪怕只有一个），此类就有一个指向vtable的指针，此指针的地址一般在前面（和类是同样的地址），然后才是成员变量。所以如果一个类中含有一个虚函数和另一个int型变量，其sizeof为8,而如果没有虚函数，sizeof为4.在运行时，为了实现多态，要查看vtable. 这样会导致程序效率低下。
指针子向父赋值时，可以直接赋值，不会出警告。转换时有dynamic_cast，此转换只用在父子之间有虚函数，用在多态时实现。如果转换不成功，指针返回NULL，引用为抛出异常（UNIX下异常为已放弃）。
7.virtual函数（成员函数多态实现）
#include <iostream>
using namespace std;
class CAnimal{
public:
virtual void eat(){cout<<"animal eat"<<endl;}
void sleep(){cout<<"animal sleep"<<endl;}
};
class CDog{
public:
virtual void eat(){cout<<"dog eat"<<endl;}
//void sleep(){cout<<"animal sleep"<<endl;}
};
int main()
{ CAnimal a;
CDog d;
CAnimal *pa;
CDog *pd;
pa=(CAnimal *)&d;
//pd=(CDog *)&a;
pa->eat();
//pd->eat();
return 0;
}
//如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。不能实现函数多态，所以派生类也要加virtual.如果不加virtual,会出现段错误。
//实现多态首先要在空间中有两个可以实现多态的函数，然后一个覆盖另一个。
实现覆盖的条件：1。 函数名字、参数列表、返回值都要一样 2.函数的访问权限不能更小。 3. 抛出的异常不能更多。
注意覆盖同隐藏的区别。
静态绑定：编译期绑定。 动态绑定：运行期绑定。
指针调用的函数由指针的类型来决定（包括强制类型转化也是这样），当有virtual函数时，要看具体的对象谁覆盖。
8.typeid
Typeid用在运行时的指针类型或者引用指向的类型，它只关心数据类型，和sizeof一样的性质。可以typeid(类名或者对象或者指针)，返回值为type_info对象的引用，如const type_info &r = typeid(类名),cout<<r.name()<<endl; 输出类名（在unix下先输出类名的长度，然后是类名）。若此类中无virtual不能实现多态，则typeid为编译时的类型，否则为运行时类型，它实际指向对象的类型。Typeid主要用在多态时看指针指向的对象的类型，（引用和指针一样使用）。
多态时的析构函数：当类中有虚函数时，析构函数也要是虚函数，以保证父类指针或引用到子类时，能正常的析构，不然会有问题的。
Cin.clear()是清除错误标志，不会清空缓冲区。
Int x; cin>>x; 当输入不是int型数据时，c++ 会按逻辑假来处理数据，此时C++会在错误情况下，拒绝工作，要cin.clear()清一下缓冲区才能正常工作。如：
If( !cin )
{ cin.clear(); cin.ignore(100,’\n’);} 第二条语句是清除缓冲区，清100个字符，直到’\n’。要先清除错误标志，才可以清空缓冲区。
Istringstream 和 ostringstream 。istringstream is(str);
在进行格式控制时，实际是通过对设置的某一位进行置 0 或置 1来实现的。
异常处理：
Throw的作用是导致一系列回退，直到找到一个catch。Void fa() throw(此函数抛出的异常类型)，try{可能出现异常操作的代码}catch(此函数中处理的异常类型){对异常的处理} throw(此函数重新抛出的异常)。 当异常处理后，程序只是恢复到正常工作的状态，但是不会从异常那里继续执行代码。若在构造或者析构函数中出现异常，则在构造函数中用new分配的空间不会释放。
当using namespace 定义时，此定义的代码不能写在函数体中，因为其中的变量都等于是全局变量。若在一个函数中，有同其中名字相同的局部变量，则在此函数中用局部变量，其它的全局变量都在：：匿名空间里面。当用＝{}给变量直接赋初值时，只适用于其中变量都为public的情况而且其中没有显式的构造函数，此时class和struct是一样的。 默认的形参有this指针。 类对象声明的位置：若在全局中，则其中的基本数据类型为默认值，成员类要用构造函数。若在局部，基本数据类型为随机值，成员类也要调用构造函数。 （foo bar::f(0)对类型为foo 的bar的类成员 f 赋初值）。
若一个类中有string成员变量，则构造函数：noname(string s){pstring=new string(s);}
Copy构造函数：noname(const noname &n){pstring =new string(*n.pstring);};析构函数：
~noname(){if(pstring) delete pstring;}。
若狗是从动物类继承而来的，则一个狗对象可以转化为动物对象，因为狗对象本来就发生动物，但是将一个动物对象转化为狗对象是错的，因为动物对象不能转化为狗对象。
Typeid在#include <typeinof> typeid()中的参数不能为指针本身，要为指针指向的对象或类型。
当一个类中有虚函数时，其析构函数也要写成虚类的。不然将父类指针new指向子类对象时，不能正确的构构。比如animal *pa=new dog;会构造狗类（先构造动物类），然后析构动物类。dog *pd=new animal;时，先构造动物类，再析构狗类（然后析构动物类），这样根据编译的时候的指针的指向类型来析构，是不对的。当析构函数为虚析构函数时，会正确的析构它所构造和析构的对象。
当 void fa() throw() throw()中什么也没有表示不抛任何异常，若为void fa() 表示抛任何异常。 Try{ 表示要处理此段代码中的异常（如果有的话） } catch(异常的类型（一般在这里可以是对象，如果是对象的话，要为引用）) {在此中为对异常的处理} throw() 表示这个函数还要抛什么类型的异常。
C++中对struct的处理和c中的不一样，在C++中，struct是当作一个类来处理的，它里面有默认的构造函数，析构函数，赋值构造函数等一个类应该有的默认的函数，只是其中数据都是公有的。而在C中的结构体不是类。