C++类和对象（结尾篇）

最新推荐文章于 2024-04-27 15:25:53 发布

Zfox_

最新推荐文章于 2024-04-27 15:25:53 发布

阅读量1k

点赞数 69

文章标签： c++

本文链接：https://blog.csdn.net/weixin_50776420/article/details/137843903

版权

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. 类中包含以下成员，必须放在初始化列表位置进行初始化:
(1)引用成员变量
(2)const成员变量
(3)自定义类型成员(且该类没有默认构造函数时)

class B
{
public:
    B(int a, int ref)
    :_aobj(a)
	,_ref(ref)
	,_n(10) {}
private:
	A _aobj; // 没有默认构造函数 
	int& _ref; // 引用
	const int _n; // 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

1.初始化列表，不管你写不写，每个成员变量都会先走一遍
2.自定义类型的成员会调用默认构造(没有默认构造就编译报错)
有参数的也报错，因为默认构造是无参的
3.内置类型有缺省值用缺省值，没有的话，不确定，要看编译器，有的编译器会处理，有的不会处理
4.先走初始化列表 + 再走函数体

很关键的一点：缺省值是给初始化列表用的

隐式类型转换与explicit关键字

class A
{
public:
	//单参数构造函数
	//explicit A(int a)
	A(int a)
	:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	
	//多参数构造函数
	A(int a1, int a2)
	:_a(0)
	,_a1(a1)
	,_a2(a2)
	{}
	
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}	
private:
	int _a;
	int _a1;
	int _a2;
};
	
int main()
{
	A aa1(1);
	// 拷贝构造
	A aa2 = aa1;
	
	 **隐式类型转换**
	1.内置类型转换为自定义类型
	2.构造一个A的临时对象，在用这个临时对象拷贝构造aa3
	3.编译器遇到连续构造 + 拷贝构造 -> 优化为直接构造
	A aa3 = 3;

	raa 引用的是类型转换中用3构造的临时对象 
	const A& raa = 3;
		
	A aaa1(1, 2);
	A aaa2 = { 1, 2 };
	const A& aaa3 = { 1, 2 };
	
	return 0;
}

补充：explicit 修饰构造函数，禁止类型转换
explicit A(int a) 就不能实现隐式类型转换

Satic成员

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

特性：
1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

注意： 不能给静态成员变量缺省值，因为它不走初始化列表。
我们之前讨论过，缺省值是给初始化列表用的，但是static不在对象中
在类外初始化。

链接: 一道熟悉static用法的题目

答案：

//用静态成员变量来做
//调用n次构造函数
class Sum
{
public:
	//每构造一次就会调用一次
    Sum()
    {
        _ret += _i;
        _i++;
    }
    //返回私有变量
    static int Getret()
    {
        return _ret;
    }
private:
    static int _i;
    static int _ret;
};

//static成员变量的初始化
int Sum::_i = 1;
int Sum::_ret = 0;

class Solution {
public:
    int Sum_Solution(int n) {
        Sum arr[n];  //定义n个sum对象 n次构造
        return Sum::Getret();
    }
};

思考题：

静态成员函数可以调用非静态成员函数吗? 不可以（没this指针不能访问内部成员）
非静态成员函数可以调用类的静态成员函数吗? 可以

友元

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

友元类

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

1.友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
2.友元关系是单向的，不具有交换性.比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time
类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
3.友元关系不能传递
如果B是A的友元，C是B的友元，则不能说明C时A的友元。
4.友元关系不能继承，在继承位置再给大家详细介绍

内部类

概念:
1.如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
2.注意:内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

特性:
1. 内部类可以定义在外部类的public、protected、private都是可以的。
限制成private就只有这个类可以使用
2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3. sizeof(外部类) = 外部类，和内部类没有任何关系。
sizeof(A) 就是A本身和B无关 仅仅收到类域的限制

class A
{ 
private:
	static int k;
    int h;
public:
	//独立的类 放到A里面
	//仅仅收到类域的限制
	class B // B天生就是A的友元 
	{
	public:
        void foo(const A& a)
        {
            cout << k << endl;//OK
            cout << a.h << endl;//OK
        }
	}; 
};

上一题的内部类实现：

//用静态成员变量来做
//调用n次构造函数

class Solution {
    //专属友元内部类
    class Sum
    {
    public:
        Sum()
        {
            _ret += _i;
            _i++;
        }
    };
    static int _i;
    static int _ret;
public:
    int Sum_Solution(int n) {
        Sum arr[n];  //定义n个sum对象 n次构造
        return _ret;  //可以直接访问
    }
};

int Solution::_i = 1;
int Solution::_ret = 0;