C++11还支持委托构造函数。 委托构造函数允许构造函数调用同一个类的其他构造函数，该构造函数必须放在构造函数初始化器中。 例如：

#include
using namespace std;
class A
{
private:
int i=5;
string str=”初始值”;
public:
A(){
str=”委托构造函数”;
i=99;
}
A(int ii):A(){
//不能写成AA(int ii):A(),i(ii)
//委托构造函数不能再利用初始化器初始化其他数据成员
i=ii;
}
void show(){
cout<<”i=”<<i<<”,str=”<<str<<endl;
}
};
int main()
{
A a(10);
a.show();
}

运行结果： 但是要注意不要递归委托：例如

#include
using namespace std;
class A
{
private:
int i=5;
string str=”初始值”;
public:
A(string ss):A(555){
str=ss;
}
A(int ii):A(“OK”){
//不能写成AA(int ii):A(),i(ii)
//委托构造函数不能再利用初始化器初始化其他数据成员
i=ii;
}
void show(){
cout<<”i=”<<i<<”,str=”<<str<<endl;
}
};
int main()
{
A a(10);
a.show();
}

编译结果： 可以看出，编译并不会报错，但是运行的时候就出错了！  

—————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

C++有一种特殊的构造函数叫做复制构造函数，允许所创建的对象是另一个对象的精确副本。如果没有编写，编译器将自动生成一个。利用源对象相应数据成员的值初始化新对象的每个数据成员。

#include
using namespace std;
class A
{
private:
int i;
string str;
public:
A(int ii,string s):i(ii),str(s){

}
/*
A(const A &a){//为了提高效率，一般参数使用引用，并且使用const保证不改变原来的值
cout<<”before copy ,i=”<<i<<”,str=”<<str<<endl;
//这一句间接说明了int类型如果不赋初始值时其值时不确定的，取决于当时内存中的值
i=a.i;
str=a.str;
cout<<”复制函数已经调用”<<endl;
}
*/
A(const A &a):i(a.i),str(a.str){
//最好使用初始化器的方式初始化
cout<<”复制函数已经调用”<<endl;
}
void show()const{
cout<<”i=”<<i<<”,str=”<<str<<endl;
cout<<”address:&i=”<<&i<<”,&str=”<<&str<<endl<<endl;
}
};
int main()
{
A a(10,”hello”);
cout<<”this is a:”<<endl;
a.show();

cout<<”this is b:”<<endl;
A b(a);
b.show();

cout<<”this is c:”<<endl;
A c=b;//注意，这一个调用的也是复制构造函数，而不是赋值构造函数
//类似于声明的语句会调用复制构造函数，原因时A c=b;c当时还没创建，是不会调用operator=方法的。
c.show();
}

运行结果： 但有一点要注意的就是，如果构造函数体内有数据成员是使用new来分配空间的话，如果不手动编写复制构造函数，就会出错！  

#include
#include
using namespace std;
class A
{
private:
char *str;
public:
A(const char *s){
int len=sizeof(s);

//因为是赋值构造函数，所以在this对象中还没有str,因此不用delete []str;
str=new char[len+1];
strcpy(str,s);
}
//不定义复制构造函数
//让编译器自动生成一个
~A(){
cout<<”start delete!”<<endl;
delete []str;
cout<<”delete complete!”<<endl;
}
void show()const{
cout<<”str=”<<str<<endl;
cout<<”address:&str=”<<&str<<endl<<endl;
}
};
int main()
{
{
A a(“hello”);
cout<<”this is a:”<<endl;
a.show();

cout<<”this is b:”<<endl;
A b(a);
b.show();

cout<<”this is c:”<<endl;
A c=b;//注意，这一个调用的也是复制构造函数，而不是赋值构造函数
//类似于声明的语句会调用复制构造函数，原因时A c=b;c当时还没创建，是不会调用operator=方法的。
c.show();
}
}

运行结果： 看似似乎a,b,c的地址都不一样，一开始我也很疑惑。但是在gdb下面调试发现其实并不是这样。 而且运行的时候也提示了两次free了同一内存。看析构中的输出也可以分析出是在free中出现了问题。 用GDB调试查看： 可以看出，实际上str地址都是一样的。都是指向同一个内存单元0X603010，而&a.str的地址都不相同。难道是说&a.str是指存放这个变量地址的地址？似乎只有这样才能说的通。使用p a.str查看，果然如此。 C++11同样提供了显式默认或者删除复制构造函数。方法和默认构造函数一致。 显式默认复制构造函数。 A(const A &a)=default; 显式删除复制构造函数 A(const A &a)=delete; 这样，编译器就将禁止使用复制构造函数。编译结果： 还有一种方法就是利用移动语义以及右值引用，这里由于我也不是和熟练，就先不写了。    

—————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

C++允许将一个对象的值赋给另一个对象。 或许你认为这就是复制，然而，“复制”只在初始化对象的时候发生。 如果一个已经具有值的对象被改写了，那么更准确的来说就是“赋值”。 注意，C++提供的复制工具是复制构造函数，因为这是一个构构造函数，因此只能在对象创建的时候使用，而不能用在对象的赋值。 C++为所有的类提供了赋值工具，这个方法叫做赋值运算符，名称为operator=,实际上其实就是重载了=运算符。 例子：  

#include
#include
using namespace std;
class A
{
private:
char *str;
public:
A(const char *s){
int len=sizeof(s);
str=new char[len+1];
strcpy(str,s);
}
//删除复制构造函数
A(const A &a)=delete;
~A(){
cout<<”start delete!”<<endl;
delete []str;
cout<<”delete complete!”<<endl;
}
A &operator=(const A &a){//赋值运算符
if(this==&a)//注意检测是否是自赋值
return *this;
int len=sizeof(a.str);
delete []str;//重新分配str的内存
str=new char[len+1];
strcpy(str,a.str);
cout<<”完成对象赋值”<<endl;
}
void show()const{
cout<<”str=”<<str<<endl;
cout<<”address:&str=”<<&str<<endl<<endl;
}
};
int main()
{
{
A a(“hello”);
cout<<”this is a:”<<endl;
a.show();

cout<<”this is b:”<<endl;
A b(“world”);
b.show();

b=a;//对象赋值
b.show();
/*
cout<<”this is c:”<<endl;
A c=b;//注意，这一个调用的也是复制构造函数，而不是赋值构造函数
//类似于声明的语句会调用复制构造函数，原因时A c=b;c当时还没创建，是不会调用operator=方法的。
c.show();
*/
}
}

结果： 可以看到，执行

b=a;//对象赋值

这一句的时候用到了赋值运算符。 如果没有定义赋值运算符，C++编译器会自动生成一个类似于默认复制构造函数行为的赋值运算符。 需要注意的是要注意检测自赋值的这种情况。 还有一种情况就是：  

#include
#include
using namespace std;
class A
{
private:
char *str;
public:
A(const char *s){
int len=sizeof(s);
str=new char[len+1];
strcpy(str,s);
}
//删除复制构造函数
A(const A &a)=delete;
~A(){
cout<<”start delete!”<<endl;
delete []str;
cout<<”delete complete!”<<endl;
}
A &operator=(const A &a){//赋值运算符
if(this==&a)//注意检测是否是自赋值
return *this;
int len=sizeof(a.str);
delete []str;//重新分配str的内存
str=new char[len+1];
strcpy(str,a.str);
cout<<”完成对象赋值”<<endl;
}
void show()const{
cout<<”str=”<<str<<endl;
cout<<”address:&str=”<<&str<<endl<<endl;
}
};
int main()
{
{

A a(“hello”);
cout<<”this is a:”<<endl;
a.show();
/*
cout<<”this is b:”<<endl;
A b(“world”);
b.show();

b=a;//对象赋值
b.show();
*/
cout<<”this is c:”<<endl;
A c=a;//注意，这一个调用的也是复制构造函数，而不是赋值构造函数
//类似于声明的语句会调用复制构造函数，原因时A c=b;c当时还没创建，是不会调用operator=方法的。
c.show();

}
}

编译结果： 这说明了 A c=a;调用的不是赋值运算符而是复制构造函数。如何区分呢？ 一般来说，类似于声明的使用的是复制构造函数，类似于赋值的使用的是赋值运算符。 当然，C++11也允许显式默认和删除赋值运算符，规则和复制构造和默认构造一样。

—————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

什么是方法重载？ 方法重载也可以说是函数重载，函数的多态性。 具体来说就是将函数或者方法的名称用于多个函数，但是参数的类型或者参数的数目不同。 在这篇blog里面我只讨论类外函数的重载。 例如一个简单的例子：  

#include
#include
using namespace std;

void printf(int i){
cout<<”This is an int:”<<i<<endl;
}
void printf(const string s){
cout<<”This is a string:”<<s<<endl;
}
int main(){
int a=10;
string s=”my name is jack!”;
printf(a);
printf(s);
system(“pause”);
}

该cpp里面有两个同名的printf函数，但是两者的参数类型不同，这就是一个最简单的函数重载的例子。 当传递的参数不一样时，将调用对应的函数。 但是需要注意的是，有时候编译器会进行自动转换。  

#include
#include
using namespace std;

void printf(const char i){
cout<<”This is an char:”<<i<<endl;
}
void printf(const string s){
cout<<”This is a string:”<<s<<endl;
}
int main(){
int a=11;
string s=”my name is jack!”;
printf(a);
printf(s);
printf(67);
system(“pause”);
}

运行结果： 可以看到,int自动转换为了char类型。 如果不希望自动转换,在C++11中支持删除指定重载函数的方法.  

#include
#include
using namespace std;

void printf(int i){
cout<<”This is an int:”<<i<<endl;
}
void printf(const string s){
cout<<”This is a string:”<<s<<endl;
}
void printf(char c)=delete;
int main(){
int a=10;
string s=”my name is jack!”;
char ch=’a’;
printf(a);
printf(s);
printf(ch);

return 0;
}

这样就可以阻止自动转换了. 需要注意的是：一些看起来参数不一样的函数时不能共存的。例如  

void printf(const string s){
cout<<”This is a const string:”<<s<<endl;
}
void printf(string s){
cout<<”This is a string:”<<s<<endl;
}

以及：  

void printf(string &s){
cout<<”This is a const string:”<<s<<endl;
}
void printf(string s){
cout<<”This is a string:”<<s<<endl;
}

从编译器的角度去看printf(s);编译器根本不知道你究竟想要调用哪一个函数。 这些情况，编译器会认为是错误。 但是对于重载引用参数，这个有点不一样。例如  

#include 
#include 
using namespace std;
void printf(const string &s){
cout<<"This is a const string:"<}
void printf(string &s){
cout<<"This is a string:"<}

int main(){
string s=”my name is jack!”;
printf(s);
const string cs=”hello world!”;
printf(cs);
system(“pause”);
}
运行结果：  编译器将自动调用最匹配的那一个函数。 这个就是普通的函数重载，在类外的情况。 其实这个可以通过模板函数来代替，并且更加高效。  
#include 
#include 
using namespace std;
template
void printf(T t){
cout<<”I don’t know what it is!but I can show it –>”<<t<<endl;
}
int main(){
int a=10;
string s=”my name is jack!”;
printf(a);
printf(s);
system(“pause”);
}
 
—————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

    

    

    

  

该博文仅用于交流学习，请慎用于任何商业用途，本博主保留对该博文的一切权利。
博主博客：http://blog.csdn.net/qq844352155 转载请注明出处： 在一个类内,最常见的就是构造函数的重载了.这里我就不介绍了. 先来看看常见的类内重载.  

//method.cpp
#include
#include
using namespace std;
class base{
private:
int i;
string s;
public:
base(int ii,string ss):i(ii),s(ss){
}
virtual ~base(){
}
void add(int ii){
cout<<i<<”+”<<ii<<”=”<<i+ii<<endl;
}
void add(string ss){
cout<<s<<”+”<<ss<<”=”<<s+ss<<endl;
}

};

//main.cpp
#include “method.cpp”
int main(){

base b(10,”me”);
b.add(25);
b.add(“name is jack!”);
return 0;

};

运行结果: 这个跟类外的函数重载几乎没有区别,只是这一次需要对象来调用方法而已. GCC还有个奇怪的行为,  

//method.cpp
#include
#include
using namespace std;
class base{
private:
int i;
string s;
public:
base(int ii,string ss):i(ii),s(ss){
}
virtual ~base(){
}
void add(int ii){
cout<<i<<”+”<<ii<<”=”<<i+ii<<endl;
}
void add(string ss){
cout<<s<<”+”<<ss<<”=”<<s+ss<<endl;
}
void add(string &ss){
cout<<” This is a &string”<<s<<” “<<ss<<endl;
}

};

这个在编译的时候不会报错:但是在编译关联文件的时候却会导致歧义.  

//main.cpp
#include “method.cpp”
int main(){

base b(10,”me”);
b.add(25);
b.add(“name is jack!”);
string s=”wife is LJ”;
b.add(s);
return 0;

};

可能这个是为了留给用户更多选择的余地吧. 同时要记住是可以通过const重载的,即参数是const和非const也算是不同的参数. 在C++11里面,可以显式删除某个重载方法.例如:  

//method.cpp
#include
#include
using namespace std;
class base{
private:
int i;
string s;
protected:
int getI()const{return i;};
string getS()const{return s;};
public:
base(int ii,string ss):i(ii),s(ss){
}
virtual ~base(){
}
void add(int ii){
cout<<i<<”+”<<ii<<”=”<<i+ii<<endl;
}
void add(string ss){
cout<<s<<”+”<<ss<<”=”<<s+ss<<endl;
}
//void add(char c)=delete
};

//main.cpp
#include “method.cpp”
int main(){
base d(15,”you”);
d.add(5);
d.add(“are fine!”);
char ch=’a’;
d.add(ch);
return 0;

};

没有显式地删除add(char c)之前,运行结果为: 可以看到char被转换为了int类型,这或许不是我们想要的. 因此我们可以手动删除这个重载方法.  

#include
#include
using namespace std;
class base{
private:
int i;
string s;
protected:
int getI()const{return i;};
string getS()const{return s;};
public:
base(int ii,string ss):i(ii),s(ss){
}
virtual ~base(){
}
void add(int ii){
cout<<i<<”+”<<ii<<”=”<<i+ii<<endl;
}
void add(string ss){
cout<<s<<”+”<<ss<<”=”<<s+ss<<endl;
}
void add(char c)=delete
};

这样,编译的时候就会报错了.类外的函数重载同样支持delete操作,这里就不演示了. 这个就是类里面的函数重载了. 需要注意的是继承的时候继承类中的重载有比较大的区别.请看下一篇博文.

—————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

方法重写.是指在子类中重新编写父类中的虚函数的实现.要求子类中的函数必须跟父类中的原型一致. 包括返回值类型(协变返回类型不算)以及参数的数目,排列顺序.  

#include
#include
using namespace std;
class base{
public:
virtualvoid show(int i,string s){
cout<<i<<”+”<<s<<endl;
cout<<”This is base show!”<<endl;
}
};
class dirved:public base{
public:
virtual void show(int i,string s){
cout<<i<<”&”<<s<<endl;
cout<<”This is dirved show!”<<endl;
}
};

int main(){
base b;
b.show(10,”base”);
dirved d;
d.show(20,”dirved”);
}

通过方法的重写,即可定义同一函数在继承层次中的不同行为! 如果在子类中使用父类虚方法的名称,但是参数不同,那么这个不是重写父类的方法,也不会重载方法,而是创建一个新方法.  

#include
#include
using namespace std;
class base{
public:
virtualvoid show(int i,string s){
cout<<i<<”+”<<s<<endl;
cout<<”This is base show!”<<endl;
}
};
class dirved:public base{
public:
/*
virtual void show(int i,string s){
cout<<i<<”&”<<s<<endl;
cout<<”This is dirved show!”<<endl;
}*/
virtual void show(){
cout<<”This is void dirved show!”<<endl;
}
};

int main(){
base b;
b.show(10,”base”);
dirved d;
//d.show(20,”dirved”);
d.show();
}

这个时候,父类中的show()方法将被隐藏,即dirved类中无法再使用show(int,string)方法.  

#include
#include
using namespace std;
class base{
public:
virtualvoid show(int i,string s){
cout<<i<<”+”<<s<<endl;
cout<<”This is base show!”<<endl;
}
};
class dirved:public base{
public:
/*
virtual void show(int i,string s){
cout<<i<<”&”<<s<<endl;
cout<<”This is dirved show!”<<endl;
}*/
virtual void show(){
cout<<”This is void dirved show!”<<endl;
}
};

int main(){
base b;
b.show(10,”base”);
dirved d;
d.show(20,”dirved”);
d.show();
}

编译结果: 可以看出,对于dirved类来说,show(int,string)这个方法被隐藏起来了,即对于dirved对象来说不可见了!因此只要在子类中重新定义了父类的虚方法,父类中的所有与该方法重载的方法都将被隐藏! 这一点需要特别注意! 下面再看一些有趣的东西:  

#include
#include
using namespace std;
class base{
public:
virtualvoid show(int i,string s){
cout<<i<<”+”<<s<<endl;
cout<<”This is base show!”<<endl;
}
};
class dirved:public base{
public:
virtual void show(int i,string s){
cout<<i<<”&”<<s<<endl;
cout<<”This is dirved show!”<<endl;
}
};

int main(){

dirved d;
d.show(10,”show()”);
base &ref=d;
ref.show(100,”ref show()”);
}

子类中正确的重写了父类中的show方法, 结果没有疑问.但是如果你重写子类的show方法的时候,发现应该用double代替int,于是i更改为  

#include
#include
using namespace std;
class base{
public:
virtualvoid show(int i,string s){
cout<<i<<”+”<<s<<endl;
cout<<”This is base show!”<<endl;
}
};
class dirved:public base{
public:
virtual void show(double i,string s){
cout<<i<<”&”<<s<<endl;
cout<<”This is dirved show!”<<endl;
}
};

int main(){

dirved d;
d.show(10,”show()”);
base &ref=d;
ref.show(100,”ref show()”);
}

运行结果: 看到没有!最后那个ref.show(int,string)调用了base里面的show方法!(100可以换成9.8更明显) 明明是dirved对象的引用,怎么就调用了base里面的show方法呢?因为这实际上是创建了一个新方法! 可用override关键字来避免这种情况!  

#include
#include
using namespace std;
class base{
public:
virtualvoid show(int i,string s){
cout<<i<<”+”<<s<<endl;
cout<<”This is base show!”<<endl;
}
};
class dirved:public base{
public:
virtual void show(double i,string s)override{
cout<<i<<”&”<<s<<endl;
cout<<”This is dirved show!”<<endl;
}
};

int main(){

dirved d;
d.show(10,”show()”);
base &ref=d;
ref.show(95.9,”ref show()”);
}

override表示你是想要重写base类的show方法而不是创建一个新的show方法,因此如果参数不对就会报错! 需要注意的是,即便是重写,只要在子类中重新定义了,父类中的相应重载函数都将会被隐藏! 如果不想既想使用父类中的show,又想重写某一个show(),可以利用using   

#include
#include
using namespace std;
class base{
public:
virtualvoid show(int i,string s){
cout<<i<<”+”<<s<<endl;
cout<<”This is base show!”<<endl;
}
virtual void show(){
cout<<”this is a void show”<<endl;
}
};
class dirved:public base{
public:
//using
using base::show;
virtual void show(int i,string s)override{
cout<<i<<”&”<<s<<endl;
cout<<”This is dirved show!”<<endl;
}
};

int main(){

dirved d;
d.show(10,”show()”);
base &ref=d;
ref.show(95.9,”ref show()”);
d.show();
}

这样就两全其美啦! —————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

要永远记得将析构函数声明为virtual—-><<effective c++>> 或许你觉得这句话不一定对,但无需质疑的是这句话是很有用的. 查看下面的例子:  

#include
#include
using namespace std;
class B{
public:
~B(){
cout<<”base is destroyed!”<<endl;
}
};
class D:public B{
public:
~D(){
cout<<”dirved is destroyed!”<<endl;
}

};

int main(){
{
D d;
}
}

这个是一个很简单的例子,输出是肯定的. 但是,再看下面的测试!  

#include
#include
using namespace std;
class B{
public:
~B(){
cout<<”base is destroyed!”<<endl;
}
};
class D:public B{
public:
~D(){
cout<<”dirved is destroyed!”<<endl;
}

};

int main(){
{
B *b=new D();
delete b;
}
}

因此可以看到,当用一个基类的指针指向一个派生类的对象,直接删除该指针时,析构函数调用链将会遭到破坏.  

#include
#include
using namespace std;
class B{
public:
virtual ~B(){
cout<<”base is destroyed!”<<endl;
}
};
class D:public B{
public:
virtual ~D(){
cout<<”dirved is destroyed!”<<endl;
}

};

int main(){
{
B *b=new D();
delete b;
}
}

因此应该记得将析构函数声明为virtual,这样就永远不用担心析构函数调用链遭到破坏!  

—————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

在C++里面，虚函数是一类重要的函数！可以通过虚函数定义不同对象同一行为的不同实现。

举一个简单的例子：

#include
#include
using namespace std;
class Animal{
protected:
string name;
public:
Animal(const string &s):name(s){
}
virtual ~Animal(){
}
virtual void speak()const{
cout<<”I’m a Animal!”<<endl;
}
};
class Dog:public Animal{
public:
Dog(const string &s):Animal(s){
}
virtual ~Dog(){
}
virtual void speak()const override{
cout<<”This’s a Dog!”<<endl;
}
};
int main(){
Animal a(“AnimalOne”);
Dog d1(“DogOne”);

//用指针调用speak()
Animal *p1=&a;
Animal *p2=&d1;
p1->speak();
p2->speak();
//用引用调用speak()
Animal &r1=a;
Animal &r2=d1;
r1.speak();
r2.speak();

return 0;

}

结果: 可以看出,通过指针和引用可以调用对应的虚函数.即便指针和引用都声明为Animal 类型,但是却可以调用相应的函数(Dog::speak()). 因此,如果需要在派生类中重新定义基类的方法,应该将该方法设置为虚方法. 需要注意的是只有指针和引用才能正确引发相应的虚函数.同时函数必须声明为虚的.如果不是的话,将只会调用相应的类成员函数. 例如:  

#include
#include
using namespace std;
class Animal{
protected:
string name;
public:
Animal(const string &s):name(s){
}
virtual ~Animal(){
}
void speak()const{
cout<<”I’m a Animal!”<<endl;
}
};
class Dog:public Animal{
public:
Dog(const string &s):Animal(s){
}
virtual ~Dog(){
}
void speak()const {
cout<<”This’s a Dog!”<<endl;
}
};
int main(){
Animal a(“AnimalOne”);
Dog d1(“DogOne”);

Animal *p1=&a;
Animal *p2=&d1;
p1->speak();
p2->speak();

Animal &r1=a;
Animal &r2=d1;
r1.speak();
r2.speak();

return 0;

}

运行结果: 如果成员函数不是虚的,就不能达到这样的效果.这就是动态绑定. 再看一个例子:  

#include
#include
using namespace std;
class Animal{
protected:
string name;
public:
Animal(const string &s):name(s){
}
virtual ~Animal(){
}

//非虚函数
void eat()const{
cout<<”Animal eat!”<<endl;
}

//不被重写的虚函数
virtual void run()const{
cout<<”Animal run!”<<endl;
}

//会被重写的虚函数
virtual void speak()const{
cout<<”I’m a Animal!”<<endl;
}
};
class Dog:public Animal{
public:
Dog(const string &s):Animal(s){
}
virtual ~Dog(){
}

//新定义的函数eat,将掩盖旧的版本,非重写(重写是指重写virtual函数)
void eat()const{
cout<<”Dog eat!”<<endl;
}

//重写speak()
virtual void speak()const override{
cout<<”This’s a Dog!”<<endl;
}
};
int main(){
Animal a(“AnimalOne”);
Dog d1(“DogOne”);

Animal *p1=&a;
Animal *p2=&d1;
p1->speak();
p2->speak();
p1->eat();
p2->eat();//call Animal::eat()
p1->run();
p2->run();//call Animal::run()

Animal &r1=a;
Animal &r2=d1;
r1.speak();
r2.speak();
r1.eat();
r2.eat();
r1.run();
r2.run();

return 0;

}

结果:   —————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

引用变量在创建的时候就必须初始化。无法创建一个未被初始化的引用。

#include
using namespace std;
int main()
{
int x=10;
int y=20;
int &r1;
}

编译结果： 如果引用未被初始化，编译将报错。   修改引用： 引用总是指向初始化的那个变量，也就是说，引用一旦被创建并初始化之后就无法改变。这一规则有点让人迷惑。、 如果声明了一个引用的同时使用一个变量赋值了，那么这个引用就会一直指向这个变量。 在此后使用变量对引用赋值，被引用变量的值变为被赋值变量的值。而引用不会因此更新从而指向这个变量。 例子：  

#include
using namespace std;
int main()
{
int x=10;
int y=20;
cout<<”&x=”<<&x<<endl
<<”&y=”<<&y<<endl;
//初始化引用，r1指向x
int &r1=x;
cout<<”&r1=”<<&r1<<”,r1=”<<r1<<endl;
//这里只是改变了r1的值，并没有改变r1指向的引用
r1=y;
cout<<”&r1=”<<&r1<<”,r1=”<<r1<<endl;
//更改引用也会更改原来的值
r1=30;
cout<<”&r1=”<<&r1<<”,r1=”<<r1<<endl;
cout<<”finally &x=”<<&x<<”,x=”<<x<<endl;

cout<<r1<<endl;
cin.get();

}

运行结果： 注意：对引用取地址的结果和对被引用的变量取地址的结果是相同的！ 可以看出，改变的只是引用变量x的值，并没有改变引用的指向. 或许你试图想通过在给引用赋值的时候取y的地址，绕过这一限制，r1=&y; 但是这样编译会报错 r1的实质是一个int型的引用，而&y则是一个int的指针，两者不能转换。 无法创建未命名值（例如一个整型值11，实质上这就是一个右值）的引用，除非这是一个const值。  

#include
using namespace std;
int main()
{
int &r1=11;
}

编译结果：(rvalue是右值的意思，lvalue是左值，rightvalue,leftvalue) 这句语句意味着可以改变11的值，而这样做是没有意义的。 但是如果是const的引用，则可以运行。

—————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

一：在Windows下测试

//测试环境为Windows7 32bit,IDE为VS2010

测试源码：

#include
using namespace std;

//基础类型及共用体测试

union unionOne{//长度为1,无疑问
char c;
};
union unionTwo{//长度=4，说明了共用体的长度是所有元素长度中长度最长那个变量的，无疑问
char c;//sizeof(char)=1
int number;//sizeof(int)=4
};
union unionThree{//长度为8，即double的长度，无疑问
char c;
int i;
double d;

};

//结构体
struct structZero//长度为1，无疑问
{
char c;
};

int main()
{
//基本类型测试
cout<<”sizeof(int)=”<<sizeof(int)<<endl;//4
cout<<”sizeof(float)=”<<sizeof(float)<<endl;//4
cout<<”sizeof(double)=”<<sizeof(double)<<endl;//8
cout<<”sizeof(short)=”<<sizeof(short)<<endl;//2

cout<<”sizeof(char)=”<<sizeof(char)<<endl;//1
cout<<”sizeof(bool)=”<<sizeof(bool)<<endl;//1
cout<<”sizeof(true)=”<<sizeof(true)<<endl<<endl;//1

//可以看出，这里的指针的长度都是4
cout<<”sizeof(int*)=”<<sizeof(int*)<<endl;//4
cout<<”sizeof(char*)=”<<sizeof(char*)<<endl;//4
cout<<”sizeof(double*)=”<<sizeof(double*)<<endl;//4
cout<<”sizeof(double**)=”<<sizeof(double**)<<endl<<endl;//4

//可以看出，union的长度即里面长度最大的成员的长度
cout<<”sizeof(unionOne)=”<<sizeof(unionOne)<<endl;//1
cout<<”sizeof(unionTwo)=”<<sizeof(unionTwo)<<endl;//4
cout<<”sizeof(unionThree)=”<<sizeof(unionThree)<<endl<<endl;//8

cin.get();

}

测试结果：   二：在fedora20/linux  64bit下测试 gcc version=4.8.2   可以看出，在Windows 32bit里面，指针是用4个字节来表示的，也就是4*8=32bit； 在linux 64bit里面，指针用8个字节表示，8*8=64，可以看出这里面的规律了吧。那么在16bit里面，是不是用16/8=2来表示的呢？ 这个留给你们自己去测试吧。 —————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————