C++基础验证篇（三）

一、c++静态成员和临时对象
#include
using namespace std;
class human
{
public:
human()
{
human_num++;
}
static int human_num;
~human()
{
human_num--;
print();
}
void print()
{
cout<<"human num is:"< }
};


int human::human_num = 0;
human f1 (human x)
{
x.print();
return x;
}
int main(int argc,char *argv[])
{
human h1;
h1.print();
human h2=f1(h1);
h2.print();
return 0;
}
此程序的意思就是静态成员用human_num记录类human的实例数。然而，由于默认的复制构造没有对静态成员操作，导致了执行结果的不正确，这里可以添加一个自定义的复制构造函数解决。
human(human &h)
{
human_num++;
}

二、临时对象的理解
产生条件：1、参数按值传递2、返回值按值传递

#include
using namespace std;
class Test
{
public:
Test():num(0){}//默认构造函数
Test(int number):num(number){} //带参数的构造函数
void print()
{
cout<<"num = "< ~Test()
{
cout<<"destructor :this = "<< this<<",num = "< }
private:
int num;
};


void fun1(Test test)
{
test.print();   //参数按值传递
}


Test fun2()
{
Test t(3);
return t;    //返回值按值传递
}


int main(int argc, char * argv[])
{
Test t1(1);


fun1(t1);           //对象传入
fun1(2);            //整形数2传入
t1 = fun2();
return 0;
}

程序中的fun1函数的参数是按值传递的，fun2函数的返回值是按值传递的，在Test类的析构函数中打印了this指针的值
fun（t1）使用复制构造函数创建临时对象
fun（2）使用是带参数的构造函数创建临时变量
如果要避免临时变量的产生，就可以使用按引用产地代替按值传递，但是引用必须是一个实在的，可引用的对象，否则引用时错误的，因此，在没有实在的，可引用的对象的时候，只有依赖于临时对象。
三、c++重载的原理
   c++的重载函数经过编译器处理后，两个函数的符号是不相同的，例如add函数，经过处理后变成了_int_add_int_int，而另一个编程_float_add_float_float。这样的名字包含了函数名，函数参数数量及返回值信息，c++靠这种机制实现函数重载的
四、重载和覆写的区别
    重载是指子类改写父类的方法，覆写是指同一个函数的不同版本之间的参数不同
    重载是编写一个与已有函数名相同但是参数表不同的方法。
     覆写是派生类重写基类的虚函数，它有以下特征：
    1.只有虚方法和抽象方法才能够被覆写
    2.相同的函数名
     3.相同的参数列表
    4.相同的返回值类型
   重载是一种语法规则，由编译器在编译阶段完成，不属于面向对象的编程，而覆写是由运行阶段决定的，是面向对象编程的特征。
#include
using namespace std;
class MyString
{
public:
MyString (char *s)
{
str = new char[strlen(s1)+1];
strcpy(str,s);
}
~MyString()
{
delete []str;
}


MyString &operator =(MyString &string)
{
if(this == &string)
{
return this;
}
if(str != NULL)
{
delete []str;
}


str =new char[strlen(string.str)+1];
strcpy(str, string.str);
return *this;
}


MyString &operator +(MyString &string) //重载+ 改变被加对象
{
char *temp = str;
str = new char[strlen(temp)+strlen(string.str)+1];
strcpy(str,temp);
delete []temp;
strcat(str, string.str);
return *this;
}


MyString &operator +(MyString &string)//重载+ 不改变被加对象
{
MyString *pString =new MyString("");
pString->str  = new char[strlen(str)+strlen(string.str)+1];
strcpy(pString ->str, str);
strcat(pString ->str, string.str);
return *pString;
}
void print()
{
cout< }
private:
char *str;
};


MyString &operator +(MyString &left, MyString &right) //重载+ 不改变被加对象
{
MyString *pString = new MyString;
pString->str = new char[strlen(left.str)+ strlen(right.str)+1];
strcpy(pString->str,left.str);
strcat(pString->str,right.str);
return *pString;
}


int main(int argc, char *argv[])
{
MyString a("hello");
MyString b("world");
MyString c("");
c=c+a;
c.print();
c=c+b;
c.print();
c=a+b;
a.print();
c.print();
return 0;
}
1.第一个版本返回*this对象，改变了被加内容
2.第二个版本属于类的成员函数，第三个版本是类的友元函数
3.由于类的友元函数不能使用私有成员，因此在使用第三个时候，需要把str转换成public。