经典C++ part1

本文旨在理解C++里面，如何给函数传参，函数返回值的原理和过程，对象的拷贝构造，以及重载类的"="运算符好， 仿函数。如果你有上面这些知识点的迷惑和不解可以参阅本篇的内容。

c++函数返回值与引用

对于函数的返回值，看似简单，但并非如此，比如：

int func(int a);该函数会返回一个int型，如果进行一个调用int result=func(3);会发生什么情况？

首先，func将返回值复制到一个匿名临时变量中，在这里假设该临时变量为anony（其实是没有名字的，这里方便阐述）；然后，再将anony的值复制到result，可以看出，这里是进行了两次复制的。而并非一次复制。

 

对于返回引用的函数：

int & func(int &a);假设该函数传入一个int的引用，然后再func中修改它，再返回其引用，如果调用int reslut=func(b);会发生如下情况：

返回的是b的引用，因此相当于直接将b的值复制给了result。这里就只有一次复制（少了临时变量的复制，当然也创建了一个临时变量，只是该临时变量是b的一个引用）。

需要特别注意的是，按很多人的理解，这里返回的是一个引用，因此result就是b的引用，其实并非如此，这里返回引用只是减少了一次临时变量值的复制。如果真的要让result能够引用b，可以这样做：int &result = func(b);

注：返回普通变量的引用看不出效率的差异，但是返回比较大的类或者结构体的时候效率差异比较明显。

 

那如果是这样申明函数int func(int a);注意，这里返回的不是引用。然后int &result=func(a);会发生什么情况呢？

如果是这样，编译器将报错：不能用一个临时变量来初始化一个非常量的引用变量。

要消除这种报错，可以这样写const int &result=func(a);这样虽然返回的不是引用，但是由于最后赋给的是一个引用变量，因此在返回过程中也只有一次复制过程。但是这样的result是不能修改其引用的内容的。

 

还有一种看似更为诡异但却十分合理的情况：

int &func (int &a);同样假设该函数传入一个int的引用，在func中修改它，然后返回其引用。然后这样调用func(b)=3;这样的后果是，传入的b的值变为3。原因是func返回了一个b的引用，然后再将该引用赋为3，因此b的值也变成了3。

如果要禁止这种情况的发送，可以这样声明函数：const int &func(int &a);这样返回的是一个const引用，它不允许使用该引用修改其指向的值。因此如果有func(b)=3这样的调用，将通不过编译。

c 拷贝构造函数

C++拷贝构造函数(深拷贝，浅拷贝)

对于普通类型的对象来说，它们之间的复制是很简单的，例如：
int a=88;
int b=a; 
而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量。下面看一个类对象拷贝的简单例子。 

#include <iostream>
using namespace std;

class CExample {
private:
    　int a;
public:
    　CExample(int b)
    　{ a=b;}
    　void Show ()
    　{
        cout<<a<<endl;
    }
};

int main()
{
    　CExample A(100);
    　CExample B=A;
    　B.Show ();
    　return 0;
} 

运行程序，屏幕输出100。从以上代码的运行结果可以看出，系统为对象B分配了内存并完成了与对象A的复制过程。就类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。下面举例说明拷贝构造函数的工作过程。

#include <iostream>
using namespace std;

class CExample {
private:
    int a;
public:
    CExample(int b)
    { a=b;}
    
    CExample(const CExample& C)
    {
        a=C.a;
    }
    void Show ()
    {
        cout<<a<<endl;
    }
};

int main()
{
    CExample A(100);
    CExample B=A;
    B.Show ();
    return 0;
} 

浅拷贝和深拷贝

　　在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。

　　深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。下面举个深拷贝的例子。

#include <iostream>
using namespace std;
class CA
{
　public:
　　CA(int b,char* cstr)
　　{
　　　a=b;
　　　str=new char[b];
　　　strcpy(str,cstr);
　　}
　　CA(const CA& C)
　　{
　　　a=C.a;
　　　str=new char[a]; //深拷贝
　　　if(str!=0)
　　　　strcpy(str,C.str);
　　}
　　void Show()
　　{
　　　cout<<str<<endl;
　　}
　　~CA()
　　{
　　　delete str;
　　}
　private:
　　int a;
　　char *str;
};

int main()
{
　CA A(10,"Hello!");
　CA B=A;
　B.Show();
　return 0;
} 

深拷贝和浅拷贝的定义可以简单理解成：如果一个类拥有资源(堆，或者是其它系统资源)，当这个类的对象发生复制过程的时候，这个过程就可以叫做深拷贝，反之对象存在资源，但复制过程并未复制资源的情况视为浅拷贝。

浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错。

        Test(Test &c_t)是自定义的拷贝构造函数，拷贝构造函数的名称必须与类名称一致，函数的形式参数是本类型的一个引用变量,且必须是引用。

当用一个已经初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用，如果你没有自定义拷贝构造函数的时候，系统将会提供给一个默认的拷贝构造函数来完成这个过程，上面代码的复制核心语句就是通过Test(Test &c_t)拷贝构造函数内的p1=c_t.p1;语句完成的。