当前位置：首页 > news >正文

十一、引用与拷贝函数（References the Copy-Constructor）

news 来源：原创 2025/4/29 7:31:18

十一、引用与拷贝函数（References & the Copy-Constructor）

11.1 指针回顾（Review of pointers）

指针可以保存一个地址。
当你定义一个指针时，必须指定它所指向变量的类型，并且应该初始化它。

示例：
```
int a = 0,b =0 ;
int* ipa = &a;
int* ipb = &b;
```
有了一个已经初始化的指针，最基本的操作是使用它修改它所指向的值。
C++允许将 任何类型的指针 赋值给一个void* 类型的指针，但不允许一个void* 指针直接赋值给其他类型的指针。

示例：
```
int i = 10;
int* p = &i;
void* vp = p;//OK
//int* ip  = vp;//error
```

11.2 引用（References）

概述

引用（&）通常用于函数参数列表和函数返回值，但你也可以创建一个独立存在的引用。
引用在创建时必须被初始化（指针可以先创建，然后再初始化）。
一旦引用被初始化为指向某个对象，它就不能被更改为去引用另一个对象。（指针可以重新指向另一个对象）

引用始终不能是NULL。必须始终能够假设引用连接到了一个合法的存储区域。

示例

int a = 3,b = 5;
int&  m=a; //ok,
int& q;//error
int& a = b;//error
int& k = m;
int n = m;
int* p = &m;
int* & ref  = p;
m = m + 5;

函数中的引用

引用作为函数参数：函数内部对引用的修改会直接影响外部实参。

返回引用时：必须保证返回的引用所指向的对象再函数外仍然存在（类似返回指针）。

错误示例：

int* f(){int*p = 9;(*p) ++;return p;//error:因为p在函数结束时就会被销毁
}int& wrongFunction() {int x = 10; // x是局部变量return x;   // 错误！x在函数结束时被销毁
}int main() {int& r = wrongFunction(); // r指向无效内存cout << r << endl;         // 未定义行为
}

因为p，x都是函数内的局部变量，因此返回之后，函数内部的局部变量就被销毁了，那么p，x就会使无定义。

正确示例：

//C11:Reference.cpp
#include <iostream>
using namespace std;
int* f(int* p){(*p) ++;return p;//安全，因为p是这个函数之外的，不会随着函数结束而被销毁
}int& g(int& x){x++;return x;//安全，因为x是这个函数之外的，不会随着函数结束而被销毁
}int&h (){int q = 0;//return q;//错误static int x = 1;return x;//安全，因为x的生命周期使整个程序
}void main()
{int a = 0;f(&a);g(a);
}

Const使用

使用 const 修饰引用参数，可以兼容更多调用情况：
```
#include <iostream>
using namespace std;
void f(int& i){i++;}
void g(const int& j){cout << j;}void main(){int a = 1;//f(1);//error,int& i = 1;f(a);//ok int& i = a;i++;g(1);// ok,1g(a); //ok,2
}
```
因为：
- g 的参数是cosnt int& j
- const int& 可以绑定到一个临时量（比如1）上
- C++明确规定了：
  
  只要是const 引用，可以直接引用常量、临时对象，编译器会在内部自动生成一个临时对象来绑定。
const引用可以接住临时值 ，因为它承诺不会修改这个值，所以是安全的。

指针的引用

当我们想要修改指针本身，而不是指针指向的内容，可以使用指针引用（int*&）更清晰

//C11:ReferenceToPointer.cpp
#include <iostream>
using namespace std;
void increment(int*& i){i++;}
void main(){int a = 2;int* p = &a;cout << "p = " << p << ":" << *p << endl;increment(p);cout << "p = " << p << ":" << *p << endl;
}

输出：

p = 000000456B8FFA24:2
p = 000000456B8FFA28:-858993460

11.3 拷贝构造函数

int i(5);
int j = i;           //通过拷贝初始化
Date today(2002,10,10); 
Date tomorrow = today;//通过拷贝初始化

想要像Date tomorrow = today 这样去初始化就需要拷贝函数。

概述

拷贝构造函数的目的：创建一个类对象时，可以用另一个已创建的同类对象的副本来初始化
如果用户已经声明了一个拷贝构造函数，那么就会使用它。如果没有，编译器会尝试生成一个公共的拷贝赋值函数。
默认的拷贝语义是成员逐一复制。
格式：X::X(const X&)

示例：

#include <iostream>
using namespace std;
class Date{int year,month,day;
public:Date(int y = 0,int m = 0,int d = 0){year = y;month = m;day = d;cout << "Constructor called." << endl;}Date(const Date& r){year = r.year;month = r.month;day = r.day;cout << "Copy construtor called." << endl;}~Date(){cout << "Destructor called." << endl;}
};void main(){Date d1(2003,9,20);Date d2 = d1;//调用拷贝构造函数
}

输出：

Constructor called.
Copy construtor called.
Destructor called.
Destructor called.

类的成员函数（包括构造函数、拷贝构造函数、析构函数、普通成员函数）， 可以访问自己类对象的 private 和 protected 成员。这里虽然 r 是一个参数对象，但是r 也是 Date 类的对象，而 Date 的成员函数是允许访问同类对象的私有成员的。简单来说，一个类的成员函数可以随意访问自己类中的其他对象的私有数据。

什么时候需要拷贝构造函数

拷贝构造函数（Copy Constructor） 会在以下情况被调用：
1. 当用一个已创建的同类对象去初始化一个新的类对象时。
```
Date d1(2003,9,20);
Date d2 = d1;
```
2. 当以值传递方式传递参数时。
3. 当一个函数返回一个对象值时。
拷贝构造函数不会被调用的情况是：
1. 当以引用传递方式传递参数时，因为没有创建新的对象。

示例：

tpoint.h

//C11:tpoint.h
class TPoint{
public:TPoint(int x,int y){X = x;Y = y;cout << "Constructor called." << X << endl;}TPoint(const TPoint& p); //copy constructor~TPoint(){cout << "Destructor called." << X << endl;}int Xcoord() {return X;}int Ycoord() {return Y;}
private:int X,Y;
};
TPoint::TPoint(const TPoint& P){X = P.X;Y = P.X;cout << "Copy Constructor called." << X << endl;
}

tpoint.cpp

#include <iostream>
#include "tpoint.h"
using namespace std;TPoint f(TPoint Q)//值传递参数，调用拷贝构造函数
{cout << "OK!" << endl;int x,y;x = Q.Xcoord() + 10;y = Q.Ycoord() + 20;TPoint R(x,y);return R;//  返回（值传递），调用拷贝构造函数
}void main(){TPoint M(20,35),P(0,0);TPoint N = M; //调用拷贝构造函数P = f(N);//调用拷贝构造函数cout << "P = " << P.Xcoord() << "," << P.Ycoord() << endl;
}

输出：

Constructor called.20		//M
Constructor called.0		//P
Copy Constructor called.20	//TPoint N = M
Copy Constructor called.20	//TPoint Q = M
OK!
Constructor called.30 // return R时拷贝的
Destructor called.20  //函数结束时 销毁这个TPoint Q = M
Destructor called.30  //函数退出时 销毁R
P = 30,40
Destructor called.20	//N.Destructor()
Destructor called.30	//P.Destructor()
Destructor called.20	//M.Destructor()

1.4 成员指针

指向数据成员的指针

//C11.PonterToMemberData.cpp
#include <iostream>
using namespace std;class Data {
public:int a, b, c;void print() const {cout << a << "," << b << ","<< c << endl;}
};
void main() {Data d;Data* dp = &d;int Data::* pmInt = &Data::a;dp->*pmInt = 47;pmInt = &Data::b;d.*pmInt = 48;pmInt = &Data::c;dp->*pmInt = 49;dp->print();
}

输出：

47,48,49

执行成员函数的指针

//C11:PointerToMemberFunction.cpp
#include <iostream>
using namespace std;
class Widget{
public:void f(int) const { cout << "Widget::f()" << endl; }void h(int) const { cout << "Widget::h()" << endl; }
};
void main() {Widget w;Widget* wp = &w;void(Widget:: * pmem)(int) const = &Widget::h;(w.*pmem)(1);(wp->*pmem)(2);
}

输出：