探索C++中的不变之美：const与构造函数的深度剖析

最新推荐文章于 2024-04-27 16:49:54 发布

W…Y

最新推荐文章于 2024-04-27 16:49:54 发布

阅读量439

点赞数 32

分类专栏： C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/m0_74755811/article/details/134167949

版权

C++ 专栏收录该内容

24 篇文章 2 订阅

订阅专栏

W...Y的主页😊

代码仓库分享💕

🍔前言：

关于C++的博客中，我们已经了解了六个默认函数中的四个，分别是构造函数、析构函数、拷贝构造函数以及函数的重载。但是这些函数都是有返回值与参数的。提到参数与返回值我们就会想到可以修饰它们的一个关键字const。而且关于构造函数，我们并没有将内容全部讲完，所以我们今天这篇博客就是对const关键字的讲解以及构造函数的补充！话不多说，我们直接开始。

const成员

const对于我们有语言基础的人并不陌生，就是关于修饰变量使其成为一个不可修改的内容。在C++中也是如此，但是C++中类的出现，伴随的出现的就是一系列的成员函数，而被const修饰的成员函数就是const成员函数。

我们来看一下这段代码：

class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << "Print()" << endl;
cout << "year:" << _year << endl;
cout << "month:" << _month << endl;
cout << "day:" << _day << endl << endl;
}

private:
int _year; // 年
int _month; // 月
int _day; // 日
};
void Test()
{
Date d1(2022,1,13);
d1.Print();
const Date d2(2022,1,13);
d2.Print();
}

上述代码是有错的，在编译器编译时就会出现

这是为什么呢？当我们使用const修饰d2时，d2的类型就是const Date类型，而我们去调用print函数去打印时，print隐藏的函数参数其实是Date* const this，所以参数不匹配导致程序报错。

那this指针的参数应该怎么是隐藏的，所以C++规定在函数后加上const的实际意义就是在this指针前加const。

所以正确的print函数应该在函数后加上const进行修饰。

void Print() const
{
cout << "Print()const" << endl;
cout << "year:" << _year << endl;
cout << "month:" << _month << endl;
cout << "day:" << _day << endl << endl;
}

这样无论在自定义类型的前面是否加上const进行修饰，都可以对上述函数进行调用。所以在调用时，我们可以将一个变量的权限放小，但是绝不能进行放大。

随之又会引出一个问题：成员函数有const进行修饰，无论实参有无const都能进行调用，那我们需不需要将所以的成员函数都加上const呢？

其实是不用的，我们加上const进行修饰的this指针指向的内容不被修改，如果我们的成员函数需要修改this指针所指向的内容，我们就不用去加const。

Date operator++(int);
Date& operator+=(int day);
Date& operator-=(int day);
Date& operator++();
Date& operator--();
Date operator--(int);

比如上述的运算符重载就不用加const，因为这些都是改变this指向的内容的。

bool Date::operator>(const Date& y) 
{
	if (_year > y._year)
	{
		return true;
	}
	else if (_year == y._year && _month > y._month)
	{
		return true;
	}
	else if (_year == y._year && _month == y._month && _day > y._day)
	{
		return true;
	}

	return false;
}
int main()
{
Date s1();
const Date s2();
s1 < s2;//正确
s2 < s1;//报错
return 0;
}

上述代码是<的运算符重载，在之前的博客中我们已经进行了复现，但是当我们的参数类型一个被const修饰，另一个没有const修饰当我们调用此函数s2 < s1时就会出现报错，因为不能将实参的权限进行放大，也就是参数类型不匹配，所以这种类似内容的函数就必须加上const进行修饰。

void Print() const;
bool operator==(const Date& y) const;
bool operator!=(const Date& y) const;
bool operator>(const Date& y) const;
bool operator<(const Date& y) const;
bool operator>=(const Date& y) const;
bool operator<=(const Date& y) const;
int operator-(const Date& d) const;
Date operator+(int day) const;
Date operator-(int day) const;

总结：

1.能定义const的成员函数都应该定义成const，这样const成员与非const成员都可以进行调用。调用条件(权限平移)(权限缩小)。

2.要修改成员变量的函数不能定义const。

取地址及const取地址操作符重载

取地址操作运算符重载也是六大默认函数之一，通过重定义对对象进行取地址操作就是取地址操作符的重载。这两个默认成员函数一般不用重新定义，编译器默认会生成。为什么会是两个呢？因为有无const是有区别的，他们会形成函数重载。

Date* operator&()
{
	cout << "Date* operator&()" << endl;

	return this;
	
}

const Date* operator&()const
{
	cout << "const Date* operator&()const" << endl;

	return this;
	
}
int main()
{
	// const对象和非const对象都可以调用const成员函数
	const Date d1(2023, 10, 31);
	d1.Print();

	Date d2(2023, 1, 1);
	d2.Print();

	cout << &d1 << endl;
	cout << &d2 << endl;

	return 0;
}

这里许多人就会有疑问，这里不会产生二义性吗？针对cout << &d2 << endl;因为d2没有被const修饰，所以既可以调用理论上来说两个函数都可以进行调用。但是C++会优先匹配最合适的类型，因为d2没有被const进行修饰，所以优先会调用没有被const修饰的函数。

如果将没有const修饰的函数进行屏蔽，两种实参照样可以进行调用。

再谈构造函数

之前我们就讲过构造函数已经将了有80%了，现在我们将构造函数中剩下的20%进行收尾。我们先来复习一下之前的构造体系：

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

这是函数体内初始化，我们进行对象的初始化时就会调用此函数，当我们没有构造函数时，我们就会调用C++提供的默认构造函数进行匹配。

构造函数的特征：
1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量
的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始
化一次，而构造函数体内可以多次赋值。

现在我们还有一种可以初始化的办法：

 Date(int year, int month, int day)
         :_year(year)
         ,_month(month)         
         ,_day(day)
         ,_ref(year)
         ,_n(1)
     {
       // 初始化列表
     }

这样的初始化我们称之为初始化列表。

初始化列表

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

class Date
{
public:
Date(int year, int month, int day)
: _year(year)
  , _month(month)
  , _day(day)
{}
private:
int _year;
int _month;
int _day;
};

这样写我们照样可以进行初始化。这两种方法都可以进行初始化，他们的区别在哪呢？

上述的例子使用两种初始化都可以，但是有些成员变量就只能使用初始化列表进行初始化。因为在类中私有成员都只是声明，没有开辟空间，而特殊的成员变量只能在定义的时候进行赋值，比如：引用、const修饰……所以我们要在初始化列表进行定义。

在内置类型中构造函数将内置类型进行赋随机值，而特殊内置类型只能赋值一次所以不能再被改变，所以我们就要一次性将其赋值好！！！

class A
{
public:
A(int a)
:_a(a)
{}
private:
int _a;
};
class B
{
public:
B(int a, int ref)
:_aobj(a)
,_ref(ref)
,_n(10)
{}
private:
A _aobj;  // 没有默认构造函数
int& _ref;  // 引用
const int _n; // const
};

所以引用成员变量、const成员变量、自定义类型成员(且该类没有默认构造函数时)都要进行初始化列表赋值。

当我们去定义一种自定义类型时，如果没有对应的构造函数，程序就会报错。所以当我们定义一个类嵌套在另一个类时，在创建类的构造函数时创建成全缺省参数的构造函数。

下面给大家看一个题：

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();
}
A. 输出1  1
B.程序崩溃
C.编译不通过
D.输出1  随机值

这道题应该选D，这是为什么呢？成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关 ，所以_a2是在私有成员中先声明的，所以在初始化中先定义_a2，因为_a1在后面所以先为随机值，所以_a2为随机值，_a1为1.

最后我们来总结一下初始化列表解决的问题：

1、必须在定义的地方显示初始化引用 const 没有默认构造自定义成员
2、有些自定义成员想要显示初始化，自己控制
3. 尽量使用初始化列表初始化
4. 构造函数能不能只要初始化列表，不要函数体初始化
答：不能，因为有些初始化或者检查的工作，初始化列表也不能全部搞定

class Stack
{
public:
    Stack(int n = 2)
        :_a((int*)malloc(sizeof(int)* n))
        , _top(0)
        , _capacity(n)
    {
        //...
        //cout << "Stack(int n = 2)" << endl;
        if (_a == nullptr)
        {
            perror("malloc fail");
            exit(-1);
        }

        memset(_a, 0, sizeof(int) * n);
    }

当我们进行动态内存开辟时，我们就需要进行函数内外的配合，因为在初始化列表中不能进行其他操作，而在函数体内可以，为了避免开辟失败，我们需要进行指针的检查，以及其他操作。所以80-100%初始化列表搞定，还有需要用函数体，他们可以混着用

以上就是本次全部内容，感谢大家观看！！！

W…Y

关注

32
点赞
踩
29

收藏

觉得还不错? 一键收藏
打赏
29
评论
探索C++中的不变之美：const与构造函数的深度剖析

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。const对于我们有语言基础的人并不陌生，就是关于修饰变量使其成为一个不可修改的内容。在C++中也是如此，但是C++中类的出现，伴随的出现的就是一系列的成员函数，而被const修饰的成员函数就是const成员函数。
复制链接

扫一扫