类与对象4-优快云博客

本文链接：https://blog.youkuaiyun.com/go_bai/article/details/146229725

补充赋值运算符：

一：流插入

class Date
{
	// 友元函数声明
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);
public:
	Date(int year = 1, int month = 1, int day = 1);

	void Print() const
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

	Date(const Date& d)   // 错误写法：编译报错，会引发无穷递归
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	// 流插入写成成员函数
	
	//d1 << cout; // d1.operator<<(cout); 
	//void operator<<(ostream& out);

private:
	int _year;
	int _month;
	int _day;
};

ostream& operator<<(ostream& out, const Date& d);

1.流插入不能写成成员函数? 因为Date对象默认占用第一个参数，就是做了左操作数

写出来就一定是下面这样子，不符合使用习惯。
写在成员函数：
void Date::operator<<(ostream& cout)   //还有一个隐藏的this指针
{
	out << _year << "年" << _month << "月" << _day << "日" << endl;
}


//使用它时必须要：d1<<cout
可是，我们平常写的时候是不是一般都是
cout<<d1
所以说很不符合我们的习惯
2.所以我们把函数写在类的成员函数外面，但是你可又发现了，我们还要使用类成员类型，可以在类外面时，我们是访问不了的，所以我们还得使用友元函数（下面会讲）。
ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;

	return out;
}
这样我们就可以实现了像平常一样使用cout输出了

二：流提取

同流插入的道理一样，我们把函数放在类的外面。

istream& operator>>(istream& in, Date& d)
{
	int year, month, day;
	in >> year >> month >> day;

	if (month > 0 && month < 13
		&& day > 0 && day <= d.GetMonthDay(year, month))
	{
		d._year = year;
		d._month = month;
		d._day = day;
	}
	else
	{
		cout << "非法日期" << endl;
		assert(false);
	}

	return in;
}

三：const成员

上面我们会发现编译不过去？这是为什么呢？

我们之前讲过：权限可以平移缩小，但不可以放大。

那么，我们想要编译通过，该怎么做呢？

C++中就以const来修饰this指针。

概念

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

写法：

 void Print()const    ---->这里就相当于：const Date* this
 {
     cout << _year << _month << _day << endl;
 }

成员函数加上const之后，我们会发现：普通和const对象都可以调用了。

结论：

我们能不能所有的成员函数都加上const呢？

不能，要修改的对象成员变量的函数不能加const。

因此：只要成员函数内部不修改成员变量，都应该加上const，这样普通和const对象都可以调用。

1. const对象可以调用非const成员函数吗？

不可以。
2. 非const对象可以调用const成员函数吗？

可以

3. const成员函数内可以调用其它的非const成员函数吗？

不可以，因为 const成员函数内不能调用其他非const成员函数。因为const成员函数承诺不修改对象，而调用非const成员函数可能会修改对象。

4. 非const成员函数内可以调用其它的const成员函数吗？

可以，因为非const成员函数内可以调用其他const成员函数。因为非const成员函数本身可以修改对象，调用不修改对象的const成员函数是允许的。

区分：

情况一：
const int a=20;
int b=a;

情况二：

const int a=20;
int& b=a;

情况三：

const int a=20;
int* pb=&a;

情况一：它是拷贝，a拷贝给b，b的改变不影响a，并不涉及权限问题，所以可以。

情况2：它的引用，b是a的别名，但是在b=a的时候，它会生成一个临时拷贝，所以b的改变影响a，这就涉及到了权限的放大，所以不可以。

情况三：同样，跟引用类似，涉及到权限的放大。

四：构造函数：初始化列表

在此之前，我们先来对比一下之前我们构造函数时的赋值和现在的初始化列表进行对比；

之前的构造函数赋值：

Date(int year = 1900, int month = 1, int day = 1)
{
    _year = year;
    _month = month;
    _day = day;
}

初始化列表：

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

Date(int year = 1900, int month = 1, int day = 1)
    :_year(year)
    ,_month(month)
    ,_day(day)
{

}

【注意】

特征：必须在定义的时候初始化

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量

const成员变量

自定义类型成员(且该类没有默认构造函数时

3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

class A
{
public:
A(int a)
:_a1(a)
,_a2(_a1)
{}
void Print() {
cout<<_a1<<" "<<_a2<<endl;
}
private:
int _a2;
int _a1;
};
int main() {
A aa(1);
aa.Print();
}

为什么第二个数字是个随机值呢？

因为这里在类中声明的顺序是：先_a2,再_a1的。那么我们看到初始化列表那么，初始化列表先初始化_a2(_a1),这时候_a1还没有初始化，所以此时它还是个随机值，赋值给_a2（也成了随机值），接着到了_a1(a),a=1,所以_a1=1

另外，之前我们学过开辟二维数组的空间，是不是得使用二层循环？现在用初始化列表后：

class AA
{
public:
	AA(int row = 10, int col = 5)
		:_row(row)
		,_col(col)
	{
		_aa = (int**)malloc(sizeof(int*) * row);
		for (int i = 0; i < row; i++)
		{
			_aa[i] = (int*)malloc(sizeof(int) * col);
		}
	}
private:
    int** _aa;
	int _row;
	int _col;
};

五： explicit关键字

构造函数不仅可以构造与初始化对象，对于接收单个参数的构造函数，还具有类型转换的作用。接收单个参数的构造函数具体表现：

1. 构造函数只有一个参数

2. 构造函数有多个参数，除第一个参数没有默认值外，其余参数都有默认值

3. 全缺省构造函数。

class A
{
public:
	/*explicit A(int a)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}*/
	
	A(int a)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}

	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}

private:
	int _a;
};

int main()
{
	A aa1(1);
	A aa2 = 2; // 隐式类型转换，整形转换成自定义类型]
	

	// error C2440: “初始化”: 无法从“int”转换为“A &”
	//A& aa3 = 2;
	/*const A& aa3 = 2;


	int i = 10;
	double d = i;*/

	return 0;

我们之前了解过：

赋值时，2构造一个A的临时对象，临时对象再拷贝构造aa2

我们现在就通过反汇编来看这两个的实质：

发现，编译器会进行优化，用2直接构造

接着，当我们下面的代码：会出现// error C2440: “初始化”: 无法从“int”转换为“A &”
A& aa3 = 2;
这里是因为生成的临时变量具有常性，不能改变变量，所以得加const

回到正内容，

class Date
{
public:
	
	explicit Date(int year)
	:_year(year)
	{
	}
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
void Test()
{
	Date d1(2024);
	// 用一个整形变量给日期类型对象赋值
	// 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值
	d1 = 2025;
}

1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译

加了explicit后出现：

// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转
换作用
// explicit修饰构造函数，禁止类型转换
explicit Date(int year, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}

用explicit修饰构造函数，将会禁止构造函数的隐式转换。

六： static成员

概念：

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化

注意：静态变量里面没有this指针

2.2 特性

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区

2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问

4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员

5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

题目：

实现一个类，计算程序中创建出了多少个类对象

class A
{
public:
	A() 
	{ 
		++_scount; 
	}
	A(const A& t)
	{ 
		++_scount;
	}
	~A() 
	{ 
		--_scount; 
	}
	static int GetACount()
	{
		return _scount;
	}
private:
	static int _scount;
};
int A::_scount = 0;
int main()
{
	cout <<__LINE__<<":" << A::GetACount() << endl;
	A a1,a2;
	cout << __LINE__ << ":" << A::GetACount() << endl;

	A a3(a1);
	cout << __LINE__ << ":" << A::GetACount() << endl;

	return 0;
}

这也证明了析构函数是完成后才销毁的。

问题：

1. 静态成员函数可以调用非静态成员函数吗？

静态能否调用非静态：不可以。非静态的成员函数调用需要this指针，我没有this

2. 非静态成员函数可以调用类的静态成员函数吗？
非静态能否调用静态：可以。

// 设计一个类，在类外面只能在栈上创建对象

// 设计一个类，在类外面只能在堆上创建对象

class A
{
public:
	static A GetStackObj()
	{
		A aa;
		return aa;
	}

	static A* GetHeapObj()
	{
		return new A;
	}
private:        //这里弄了私有的，要想要访问某一个，就单独用static开成员函数
	A()
	{}

private:
	int _a1 = 1;
	int _a2 = 2;
};

int main()
{
	//static A aa1;   //  静态区
	//A aa2;          //  栈 
	//A* ptr = new A; //  堆
	A::GetStackObj();
	A::GetHeapObj();

	return 0;
}

七：友元

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度（关联性），破坏了封装，所以友元不宜多用。

友元分为：友元函数和友元类

放的位置：类里面任意位置，放公有私有都可以。

原因：因为它只是个声明，而声明是放在哪里的都是可以的，能不能访问这个权限，编译时语法会检查的。

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字
说明:

友元函数可访问类的私有和保护成员，但不是类的成员函数

友元函数不能用const修饰

友元函数可以在类定义的任何地方声明，不受类访问限定符限制一个函数可以是多个类的友元函数

友元函数的调用与普通函数的调用原理相同

class Time
{
    friend class Date;   
public:
    Time(int hour = 0, int minute = 0, int second = 0)
        : _hour(hour)
        , _minute(minute)
        , _second(second)
    {}

private:
    int _hour;
    int _minute;
    int _second;
};

class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
        : _year(year)
        , _month(month)
        , _day(day)
    {}

    void SetTimeOfDate(int hour, int minute, int second)
    {
        // 直接访问时间类私有的成员变量
        _t._hour = hour;
        _t._minute = minute;
        _t._second = second;
    }

private:
    int _year;
    int _month;
    int _day;
    Time _t;
};

声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量

上面的代码属于友元类：

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。友元关系是单向的，不具有交换性。

比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

友元关系不能传递

以朋友为例子：

如果B是A的朋友，C是B的朋友，则不能说明C时A的朋友

八：内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

特性：

1. 内部类可以定义在外部类的public、protected、private都是可以的。

2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
class A
{
private:
    static int k;
    int h;

    class B  
    {
    public:
        void foo(const A& a)
        {
            cout << k << endl; ------>ok
            cout << a.h << endl;------>OK
        }
    private:
        int b;
    };
};
3. sizeof(外部类)=外部类，和内部类没有任何关系

我们可以看到：静态函数不算进大小。

我们也可以看到：内部类是外部类的天生友元

九：汇编角度理解类与对象


class A
{
public:
    A(int a = 0)
        :_a(a)
    {
        cout << "A(int a)" << endl;
    }

    ~A()
    {
        cout << "~A()" << endl;
    }
}；

int main()
{
   //第一种：
     A aa(1);  // 有名对象 -- 生命周期在当前函数局部域
    //第二种：
    A(2);     // 匿名对象 -- 生命周期在当前行

    //第三种：出现错误
      A& ra = A(1);  // 匿名对象具有常性

    //第四种：
     const A& ra = A(1);  

    retrun 0;
}

我们会发现第一，二种都是可以运行的，一样的结果。

第三种运行不了，第四种可以：说明了赋值时会生成一个临时变量，临时变量具有常性，直接只有会造成权限放大，所以报错，第四种中加了const后，又可以运行了，说明const引用延长匿名对象的生命周期，生命周期在当前函数局部域。

接下来，我们用代码更加直观地观察它们内部的区别：

class A
{
public:
    A(int a = 0)
        :_a(a)
    {
        cout << "A(int a)" << endl;
    }

    A(const A& aa)
        :_a(aa._a)
    {
        cout << "A(const A& aa)" << endl;
    }

    A& operator=(const A& aa)
    {
        cout << "A& operator=(const A& aa)" << endl;

        if (this != &aa)
        {
            _a = aa._a;
        }

        return *this;
    }

    ~A()
    {
        cout << "~A()" << endl;
    }
private:
    int _a;
};

void Func1(A aa)
{

}
void Func2(const A& aa)
{

}

A Func3()
{
    A aa;
    return aa;
}

A& Func4()
{
    static A aa;
    return aa;
}

一：

看汇编，它调用了构造函数和析构函数，

二：

三：

看汇编代码：

这里Func调用的是引用，并且函数里面也没有内容，所以不用另外再次调用构造函数和析构函数。

四：

看到这，我们发现函数中调用，出来函数，就会伴随着析构函数的。这也体现了之前说了出了函数就会销毁的原理。

五：

六：
int main()
{
   
   
    A ra2;
    ra2 = Func5();
    retrun 0;
}
我们可以看到 ra2 = Func5();的调用方式：是从右到左的。

七：

  A ra1 = Func5(); // 拷贝构造+拷贝构造 ->优化为拷贝构造

八：


    A aa1;
    Func1(aa1); // 不会优化

九：

Func1(A(1)); // 构造+拷贝构造 ->优化为构造

十：
Func(1);

十一：
A aa2=1；

本次分享到此结束了。

最后，本次鸡汤：

世界很大，值得怀念的地方很多，路上有人为你鼓励，有人充满激动地为你骄傲，你是路上的一道风景，你也是另一个她的偶像。