构造函数，友元，static类成员，复制控制

迈不过友情╰ 2022-08-10 14:43 147阅读 0赞

##  ##

## 构造函数 ##

1.我们可以通过将构造函数声明为explicit来防止在需要隐式转换的上下文中使用构造函数，explicit在声明上使用，在类定义体外是不能重复写explicit

class A {
    public:
    	A(const string &i):a(i){
    		cout<<"dad"<<endl;
    	}
    	A(const A& b)
    	{
    		cout<<"dagdgd"<<endl;
    	}
    	void same(const A&p)
    	{
    		cout<<"same"<<endl;
    	}
    private:
    	string a;
    };
    int main()
    {
    	A b("dada");
    	string abc = "aaa";
    	b.same(abc);//此处abc调用构造函数A(const string &i)创建一个临时对象，然后再调用拷贝构造函数
    	return 0;
    }

注：如果声明为explicit A(const string &i)则不会abc不会调用构造函数

string null\_isbn("9999");首先调用接受一个c字符串形参的构造函数，创建一个临时对象temp，然后调用复制构造函数；

A null1(null\_isbn);//调用带string形参的构造函数

A null("sasa")；首先调用一个接受一个c字符串形参的构造函数，创建一个临时string对象，然后调用使用其作为实参调用构造函数

2.类成员的显示初始化：对于没有定义构造函数并且其全体数据成员均为public的类，可以采用与初始化数组元素相同的方式初始化其成员。

## 友元 ##

1.友元机制允许一个类将对其非公有成员的访问权授予指定的函数或类。友元的声明以关键字friend开始，只能够出现在类定义的内部。

2.定义友元类 friend class 函数名; 定义友元函数 friend 返回值 函数名(形参)；

3.友元不受访问控制符的影响。

## static类成员 ##

1.static成员函数没有this形参，它可以直接访问所属类的static成员，但不能直接使用非static成员。

2.当我们在外部定义static成员时，无须重复指定static保留字

3.static成员是类的组成部分但不是任何对象的组成部分，因此，static成员函数不能声明为const

4.static成员变量的初始化应该在类定义体外面定义。只有当初始化式是一个常量表达式，整形const static数据成员就可以在类的定义体中进行初始化。

例如 double Account::interestRate = init();

# 复制控制 #

1.复制控制包括：复制构造函数、赋值操作符、和析构函数。（如果没有则编译器会自动生成）

在类中具有指针成员时，需要类定义自己的复制控制成员。

2.复制构造函数要求：只有单个形参，而且该形参是对本类类型对象的引用（常用const修饰）

初始化分为直接初始化（将初始化式放在括号中）和复制初始化（使用=符号），支持复制初始化是为了与C统发兼容

直接初始化 string dot("100");直接调用与实参匹配的构造函数

复制初始化 string s = "100"；首先使用带char \*的构造函数创建一个临时对象，然后调用复制构造函数。

3.当形参为非引用的类类型的时，由复制构造函数进行复制

4.初始化容器元素

例如vector<string> svec(5);

编译器首先使用string默认构造函数创建一个临时值来初始化svec，然后使用复制构造函数将临时值复制到svec的每个元素。

5.与合成的默认构造函数不同，即使我们定义了其他构造函数，也会合成复制构造函数

6.当有一个数据成员为指针的时候，必须重写复制构造函数

7.当将复制构造函数声明为private时，将不允许用户代码复制该类类型的对象，但是类的友元和成员仍然可以进行复制，如果想禁止友元和成员，就可以声明一个private复制构造函数，但是不对其定义。

8.当类中没有定义自己的复制操作符时，编译器会合成一个。当操作符为成员函数时，它的第一个操作数隐式绑定到this指针。

9.一般而言，如果类需要自己定义复制构造函数，那么也会需要自己定义赋值操作符。（例如类中包含指针型数据成员）

10.动态分配的对象只有在指向该对象的指针被删除时才撤销，如果没有删除指向动态对象的指针，则不会运行该对象的析构函数，对象就一直存在，从而导致内存泄露，而且对象内部使用的任何资源也不会释放。

用delete p时，删除的是指向动态分配对象的指针或实际对象超出作用域时，才会运行析构函数。

11.三法则指的是：如果需要析构函数，则它也需要赋值操作符和复制构造函数。

12.析构函数与构造函数不同点，在于它没有形参，所有不能重载析构函数。析构函数与复制构造函数和赋值操作符的一个重要区别是：即使我们编写了自己的析构函数，合成析构函数仍然运行，此时先运行自己定义的析构函数，然后再运行合成析构函数撤销类的成员。合成析构函数调用该成员的析构函数来撤销对象。

## 管理指针成员的三种不同方法 ##

1.一个带指针成员的简单类

class HasPtr{
    public:
    	HasPtr(int *p,int i):ptr(p),val(i){ }
    	int *get_ptr()const { return ptr;}
    	int get_int()const{return val;}
    	void set_ptr(int *p){ ptr = p; }
    	void set_int(int i){ val = i; }
    	int get_ptr_val()const{ return *ptr;}
    	void set_ptr_val(int val)const {*ptr = val;}
    private:
    	int *ptr;
    	int val;
    };

会出现悬垂指针，当添加析构函数删除指针对指向的对象，会是的其他由该对象复制而创建的对象中的指针成员也无法使用

2.定义智能指针类：引入使用计数

（1）智能指针类将一个计数器与类指向的对象相关联，使用计数跟踪该类有多少个对象共享同一指针。使用计数为0时，删除对象。（也称为引用计数）

计数类不能放在HasPtr中：因为创建对象时，不能更新它

计数类

class U_Ptr{
    	friend class HasPtr;
    	int *ip;
    	size_t use;
    	U_Ptr(int *p):ip(p),use(1){}
    	~U_Ptr(){delete ip;}
    };

新的HasPtr类

class HasPtr{
    public:
    	HasPtr(int *p,int i):ptr(new U_Ptr(p)),val(i){ }
    	HasPtr(const HasPtr &orig):ptr(orig.ptr),val(orig.val){ ++ptr->use;}
    	HasPtr& operator=(const HasPtr&);
    	~HasPtr(){ if(--ptr->use == 0) delete ptr;}
    private:
    	U_Ptr *ptr;
    	int val;
    };<pre name="code" class="cpp">HasPtr& HasPtr::operator =(const HasPtr &rhs)
    {
    	++rhs.ptr->use;
    	if(--ptr->use == 0)
    		delete ptr;
    	ptr = rhs.ptr;
    	val = rhs.val;
    	return *this;
    }

3.定义值型类：在复制构造函数中复制指针所值的对象，不再复制指针。自定义析构函数，析构指针所指的对象