C++（第四篇）：C++的类和对象（下 —— 再谈构造函数、static成员、成员初始化、友元、内部类）

已于 2022-12-16 09:51:03 修改
阅读量1.9k 收藏 3
点赞数 6
分类专栏： 【C++拒绝从入门到跑路】 文章标签： c++ 开发语言
于 2022-08-02 15:58:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Y673789476/article/details/126124045
版权

📒博客主页：Morning_Yang丶
🎉欢迎关注🔎点赞👍收藏⭐️留言📝
📌本文所属专栏： 【C++拒绝从入门到跑路】
✉️坚持和努力从早起开始！
🙏作者水平有限，如果发现错误，敬请指正！感谢感谢！

文章目录

一. 再谈构造函数

1.1 构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值

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

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

我们可以认为，初始化列表位置才是真正的，对成员变量进行初始化（定义）的地方，构造函数体中只是对成员变量进行赋值 =，不是初始化（定义），构造函数体执行完，对象就创建成功了。

1.2 初始化列表（🌟）

初始化较函数体赋值是更正规的初始化成员变量，当对象创建(定义)时，便是成员变量定义的时候，有些成员变量必须在定义的时候进行初始化，而这就是初始化列表的价值。

构造函数的初始化列表可以认为是成员变量定义初始化的地方。

使用：

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

class Date
{
public:
	Date(int year, int month, int day)
	: _year(year)//定义时初始化
	, _month(month)
	, _day(day)
	{}
private:
    //这里相当于是声明
	int _year;
	int _month;
	int _day;
};

【注意】

  1. 初始化列表中：只能对类中 非静态的成员变量 来进行初始化。
  2. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
  3. 类中包含以下成员，必须放在初始化列表位置进行初始化，不能使用函数体内初始化：
    • 引用成员变量 int& _ref （因为引用必须在声明时初始化）
    • const 成员变量 const int _n; （因为常变量不允许修改，必须在定义时初始化）
    • 自定义类型成员(没有默认构造函数的自定义类型成员)

这些成员有一个特征就是：必须在定义的时候进行初始化

可以理解成，一个对象的单个成员变量在初始化列表是它定义的阶段，这个时候就是直接对变量定义且初始化。函数体内初始化相当于是先定义出来，然后才赋值，不是在定义的时候就初始化。

class A
{
public:
	A(int x)
	{
		cout << "A(int x)" << endl;
		_x = x;
	}
private:
	int _x;
};
 
class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _n(10)	//const
		, _ref(year)
		, _a(1)  // 去调用构造函数
	{
		_day = day;
		//	_n = 10; // 不能在函数体内初始化，必须使用初始化列表初始化
		// _ref = year;
	}
 
private:
	// 成员变量声明
	int _year;
	int _month;
	int _day;
	
	// 他们必须在定义的时候初始化
	const int _n;//
	int& _ref;
	A _a;
};
 
int main()
{
	Date d1;
	return 0;
}
  • 尽量使用初始化列表初始化：
    • 因为不管你是否使用初始化列表，都默认为这里（构造函数体前）有初始化列表，成员变量都会在该处完成初始化。
    • 有些成员是必须在初始化列表中初始化的。
    • 初始化列表和函数体内初始化，可以混着用，互相配合。（比如带头双向循环链表的构造函数）

如果没有在初始化列表显示初始化

  1. 内置类型，有缺省值用缺省值，没有就用随机值

  2. 自定义类型，默认调用它的默认构造函数，没有默认构造函数就报错(注意：分清什么是默认构造函数)

严格来说对于内置类型，初始化列表和函数体内初始化没有差别。

对于自定义类型成员变量，一定会先使用初始化列表初始化：

一个类中有自定义类型成员变量，实例化该类对象时，会调用该类的构造函数，通过汇编代码能看到，在类的构造函数的函数体 {} 之前，有一个 call 命令，去调用了自定义类型的构造函数。（大家可以自行查看vs里面的汇编）

class Time
{
public:
	Time(int hour = 0)
		:_hour(hour)
	{
		cout << "Time()" << endl;
	}
private:
	int _hour;
};
 
class Date
{
public:
	// 自定义类型，使用初始化列表 -》 构造函数
	/*Date(int day, int hour)
		:_t(hour)
	{}*/
 
	// 自定义类型，不使用初始化列表 -》 构造函数 + operator=
	Date(int day, int hour)
	{
		_day = day;
		// 函数体内初始化
		Time t(hour);
		_t = t;
	}
private:
	int _day;
	Time _t;
};
 
int main()
{
	Date d(12, 12);
}

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

    建议：类中成员变量声明的顺序和初始化列表出现顺序保持一致

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的随机值， _a1再被赋值等于1

补充：

class A
{
public:
	A
	{}
    //什么都不做，没有写初始化列表
private:
	int _a;
	B _b;//会调用默认构造函数，被初始化
};
int main() 
{
	A aa;
}

初始化列表，不管你的构造函数是否显示的写或者不写，都会运行一遍。这个时候，即使你的构造函数什么都没有做，对象里的自定义类型变量也会在初始化列表初始化定义的时候调用它的默认构造函数(如果没有默认构造函数就会报错)。

1.3 explicit关键字

构造函数不仅可以构造与初始化对象，对于「单个参数」的「构造函数」，还具有「类型转换」的作用，而对于使用explicit修饰的构造函数，则禁止了这样的转换构造对象

单参数的构造函数，支持隐式类型转换
语法意义上是先构造临时变量，再将临时变量拷贝构造给所建对象，现在的编译器做了优化，会直接调用构造函数

class Date
{
public:
    //构造函数
    explicit Date(int year)
    :_year(year)
    {}
    //拷贝构造
    Date(const Date& aa)
    {}
private:
    int _year;
    int _month:
    int _day;
}；
void TestDate()
{
    Date d1(2020);
    d1 = 2021;
    // 用一个整形变量给日期类型对象赋值
    // 实际编译器背后会用2021构造一个无名对象，最后用无名对象给d1对象进行赋值
}

👉示例：用explicit修饰构造函数，将会禁止单参构造函数的隐式转换

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

private:
	int _a;
};

int main()
{
	A a1(10);
	A a2 = 20; // 编译器报错error:，“初始化”:无法从“int”转换为“A”

	return 0;
}

总结：

虽然这两种写法的运行结果是一样的，都是直接调用构造函数，但是对于编译器而言过程是不一样的。

image-20220424153008758

第二种写法隐式类型转换过程图（未被编译器优化前）：

image-20220424153232595
👉拓展：C++11支持多参数的隐式类型转换。同样也可以加 explicit 关键字来禁止隐式类型转换。

class A {
public:
	A(int a, int b)
		: _a(a)
        , _b(b)
	{}

private:
	int _a;
    int _b;
};

int main()
{
	A a1(10, 20);

	// 下面本质上是一个隐式类型转换
	A a2 = { 10, 20 }; // C++11支持多参数的隐式类型转换，写一个花括号把参数括起来

	return 0;
}

1.4 匿名对象

三种调用构造函数的方式
image-20220705103319128
使用场景：定义一个对象要用，但是这里只有这一行用，其他地方不用；先定义有名对象反而麻烦，直接定义匿名对象，方便快捷。

二. static成员

2.1 概念

  • static 修饰的类成员称为类的静态成员。
  • 用 static 修饰的成员变量，称之为静态成员变量；用 static 修饰的成员函数，称之为静态成员函数。
  • 静态的成员变量一定要在类外进行初始化。
//计算A定义出多少个对象
class A
{
public:
    A()
    {
        ++_n;
    }
    A(const A& a)
    {
        ++_n;
    }
    //静态成员函数和普通成员函数的区别:
    //没有this指针，不能访问非静态成员
    static int GetN()
    {
        return _n;
    }
private:
    //这里只是声明，不在构造函数初始化，在类外面全局位置初始化
    static int _n;// n存在于静态区，属于整个类，也属于类的所有对象
}
//静态成员变量的定义初始化
//初始化的时候是可以访问该私有变量的，特例，不受访问限定符限制，否则就无法初始化
int A::_n = 0;
//类似这里，const不能修改，但是定义的时候可以，否则无法初始化
//const int n = 10;
//n = 20// err

int main()
{
    A a1;
    A a2;
    
    cout<< A::_n <<endl; 	//public
    cout<< a1._n <<endl;	//public
    cout<< a2._n <<endl;	//public
    cout<< A()._n <<endl;	//public
    //如果成员变量是私有的，定义一个成员函数
    cout << a1.GetN() << endl;	//private
    cout << A().GetN() << endl;	//private
    //静态成员函数（static）访问，不需要对象
    cout << A::GetN() << endl;	//private
}

静态成员函数在类外实现以及静态成员变量在类外初始化时无须加static关键字，否则是错误的。

2.2 静态成员函数和普通成员函数的区别

静态成员函数可以直接访问该类的静态成员变量和静态成员函数，但是它没有this指针，不能访问非静态成员

静态成员函数，不属于某个对象，突破类域就能访问

关于静态成员函数，可以总结为以下几点：

  1. 在类体外定义不能指定关键字static；
  2. 静态成员之间可以相互访问，包括静态成员函数访问静态成员变量和访问静态成员函数；
  3. 非静态成员函数可以任意地访问静态成员函数和静态成员变量；
  4. 静态成员函数不能访问非静态成员函数和非静态成员变量；
  5. 由于没有this指针的额外开销，因此静态成员函数与类的全局函数相比速度上会有少许的增长；
  6. 调用静态成员函数，可以用成员访问操作符(.)和(->)为一个类的对象或指向类对象的指针调用静态成员函数，或者"类名::静态成员函数名"的方式调用，类似下面讲解调用静态成员变量。
  7. 当同一类的所有对象使用一个量时，对于这个共用的量，可以用静态数据成员变量，这个变量对于同一类的所有的对象都取相同的值。

2.3 特性

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

  2. 类静态成员变量，必须在「类中声明」，「类外单独定义」（定义时不添加 static 关键字）。

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

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

  5. 静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值

  6. static成员变量在对象生成之前生成

上述是类里面的静态变量

补充 全局静态变量和局部静态变量的区别

  1. 全局静态变量只能被当前源文件引用，不能被工程里其它源文件引用。
    除了这点特殊，其它与普通的全局变量一样。

  2. 局部静态变量，只执行一次初始化，只能被所在函数引用，函数执行完毕，变量仍存在，生存周期贯穿整个程序。

【问题】

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

    不能，静态成员函数没有隐藏的this指针，static函数唯一能够访问的就是static变量或者其他static函数

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

    可以，都在类中

回忆：

  • 在C语言中：
  • static 修饰全局变量和全局函数，改变了其链接属性，只在当前文件可见。
  • static 修饰局部变量，改变了其声明周期（即改变了该变量的存储位置），变为全局。
  • 上面的特性在 C++ 中依旧有用（因为 C++ 兼容 C 的这些特性）

2.4 练习题

JZ64 求1+2+3+…+n

描述

求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

示例1

输入：5

返回值：15

示例2

输入：1

返回值：1

思路

  1. 题目要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句A?B:C，说明不能采用常规方法进行累加求和

  2. 充分利用C++特性，构造对象构造函数会自动调用的特点，让求和在构造函数中进行完成

  3. 由于所有对象要针对相同的和进行更新，所以其成员定义为static

写法一：多个测试用例可能会多次调用，多次调用i的值没有初始化回去，可以给一个静态成员函数Init，每一次都先Init一下。

写法二：私有情况下，设置成友元

写法三：静态成员变量直接设置成公有的

//写法1：
class Add
{
public:
    Add()
    {
        _ret += _i;
        _i++;
    }
    static int Get_ret()
    {
        return _ret;
    }
    static void Init()
    {
        _i = 1;
        _ret = 0;
    }
private:
    static int _i;
    static int _ret;
};
int Add::_i = 1;
int Add::_ret = 0;
class Solution {
public:
    int Sum_Solution(int n) 
    {
        Add::Init();
        Add A[n];
        return Add::Get_ret();
    }
};
//写法二
class Add
{
    friend class Solution;
public:
    Add()
    {
        _ret += _i;
        _i++;
    }
private:
    static int _i;
    static int _ret;
};
int Add::_i = 1;
int Add::_ret = 0;
class Solution {
public:
    int Sum_Solution(int n) 
    {
        Add::_i = 1;
        Add::_ret = 0;
        Add A[n];
        return Add::_ret;
    }
};

//写法三
class Add
{
public:
    Add()
    {
        _ret += _i;
        _i++;
    }
    static int _i;
    static int _ret;
};
int Add::_i = 1;
int Add::_ret = 0;
class Solution {
public:
    int Sum_Solution(int n) 
    {
        Add::_i = 1;
        Add::_ret = 0;
        Add A[n];
        return Add::_ret;
    }
};

三. C++11 的成员初始化新玩法

C++11 支持「非静态成员变量」在「声明时」进行初始化赋值，但是要注意这里不是初始化，这里是给声明的成员变量一个「缺省值」。

构造函数对内置类型不处理，我们可以采取给缺省值的方式来 “ 打补丁 ”

如果我们在构造函数的形参列表中给了缺省值，或者在初始化列表中显式的给了值，就不会用缺省值了。

class B
{
public:
	B(int b = 0)
		:_b(b)
	{}
	int _b;
};
class A
{
public:
	void Print()
	{
		cout << a << endl;
		cout << b._b << endl;
		cout << p << endl;
	}
private:
	// 非静态成员变量，可以在成员声明时给缺省值
	int a = 10;
	B b = 20;
	int* p = (int*)malloc(4);
};

int main()
{
	A a;
	a.Print();
	return 0;
}

类似上述，可以在进行声明时给个缺省值，使得类在列表初始化的过程有缺省参数。

对于自定义类型的成员变量：

//单参数自定义类型
class A
{
public:
	A(int A = 0)
		:_A(A)
	{}
	int _A;
};
//复杂类型
class B
{
public:
	B(int b1 = 0, int b2 = 0)
		:_b1(b1)
        ,_b2(b2)
	{}
	int _b1;
    int _b2;
};
//初始化
class C
{
public:
	C()
    {}
private:
	//单参数
    A _a1 = A(1);//1
    A _a2 = 1;//2，单参数一般都这样写
    A _a3 = {1};//3
    //复杂类型
    B _b1 = B(1,1);//1
    B _b2 = {1,1}; //2
};

四. 友元

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

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

4.1 友元函数

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

输出运算符<< 和 输入运算符>>

click on an element for detailed information

它们为什么能自动识别类型？

内置类型的对象，直接就能用cout cin输入输出，是因为库里面重载好了。

并且能自动识别类型，是因为他们之间构成函数重载

image-20220704100040488

问题：现在我们尝试去重载operator<<，然后发现我们没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以我们要将operator<<重载成全局函数。但是这样的话，又会导致类外没办法访问成员，那么这里就需要友元来解决。operator>>同理。

class Date
{
    friend ostream& operator<<(ostream& _cout, const Date& d);
    friend istream& operator>>(istream& _cin, Date& d);
public:
    Date(int year, int month, int day)
        : _year(year)
            , _month(month)
            , _day(day)
        {}
private:
    int _year;
    int _month;
    int _day；
};
ostream& operator<<(ostream& _cout, const Date& d)
{
    _cout<<d._year<<"-"<<d._month<<"-"<<d._day;
    return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
    _cin>>d._year;
    _cin>>d._month;
    _cin>>d._day;
    return _cin;
}
int main()
{
    Date d;
    cin>>d;
    cout<<d<<endl;
    return 0;
}

特性:

  1. 友元函数可访问类的私有和保护成员，但不是类的成员函数，就相当于你的朋友再亲密也不是你的家人，既然不是类成员函数，那和普通成员函数调用一样，不需要通过对象调用
  2. 友元函数不能用const修饰
  3. 友元函数可以在类定义内的任何地方声明，不受类访问限定符限制
  4. 一个函数可以是多个类的友元函数
  5. 友元函数的调用与普通函数的调用和原理相同，友元函数不具备this指针

4.2 友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

class Time
{
	friend class Date;
}
  • 友元关系是单向的，不具有交换性。

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

  • 友元关系不能传递

如果B是A的友元，C是B的友元，则不能说明C是A的友元。

image-20220705202827823

class Date; // 前置声明
class Time
{
	friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
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;
};

五. 内部类

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

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

特性：

  1. 内部类可以定义在外部类的public、protected、private都是可以的。
  2. 注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。
  3. sizeof(外部类)=外部类，和内部类没有任何关系
  • 例：
class A
{
private:
	static int k;
	int h;

public:
	/* 在A类的内部定义B类 */

	class B // B天生就是A的友元
	{
	public:
		void foo(const A& a)
		{
			cout << k << endl;   // OK
			cout << a.h << endl; // OK
		}
	};
};

int A::k = 1;

int main()
{
	A::B b; // 实例化内部类B的对象
	b.foo(A());
	return 0;
}

内部类天生就是类的友元

六. 再次理解封装

C++是基于面向对象的程序，面向对象有三大特性即：封装、继承、多态。

C++通过类，将一个对象的属性与行为结合在一起，使其更符合人们对于一件事物的认知，将属于该对象的所有东西打包在一起；通过访问限定符选择性的将其部分功能开放出来与其他对象进行交互，而对于对象内部的一些实现细节，外部用户不需要知道，知道了有些情况下也没用，反而增加了使用或者维护的难度，让整个事情复杂化。

封装是一个更好的管理，受规则约束的一种管理，在生活中很多方面都体现着封装性。

比如火车站：有咨询系统，售票系统，安检系统，安保系统，卫生系统，铁路系统等等，这些系统相互配合，让大家坐火车有条不紊的进行。如果没有这些系统，变成开放性的站台呢？火车站没有围墙，大家都去扒火车，乘车也没有规矩，都去抢座位，无法想象这是怎样一番场景。

七. 再次理解面对对象

面向对象其实是在模拟抽象映射现实世界。

把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象。 对同类对象抽象出其共性，形成类。类中的大多数数据，只能用本类的方法进行处理。 类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信。

image-20220425175122684

Morning_Yang丶
关注
  • 6
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Morning_Yang丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值