C++类和对象(构造函数static成员内部类友元函数等)
Posted yumoz
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C++类和对象(构造函数static成员内部类友元函数等)相关的知识,希望对你有一定的参考价值。
1 构造函数
接着C++类和对象(2)博客中介绍的构造函数继续说一下构造函数还可以怎么玩?
玩法一:构造函数体赋值
class Date
{
public:
//全缺省 构造函数 函数体内赋值
Date(int year = 2020, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
对于构造函数在函数体内赋值,构造函数调用之后,对象中已经有了一个初始值,但不能将其称为类对象的初始化,构造函数体中的语句只能将其作为赋初值,不能作为初始化。因为初始化只能初始化一次,而构造函数体内可以多次赋值 。
玩法二:初始化列表
初始化列表是以一个冒号开始,接着后面在需要的情况下使用逗号分隔数据成员列表,每个“成员变量”后跟一个放在花括号{}中的初始值或者表达式。
class Date
{
public:
//初始化列表初始化
Date(int year = 2020, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};
注意:
1. 每个成员变量在初始化列表中只能出现一下;
2. 类中包含以下成员,必须放在初始化列表位置中进行初始化:
- 引用成员变量
- const成员变量
- 自定义类型成员(该类型没有默认构造函数)
(默认构造函数:(不用传参就可以调用的 如:全缺省构造函数,无参数构造函数,编译器自动生成的构造函数))
一些建议:
- 尽量使用初始化列表初试化,因为对于自定义类型成员变量,一定会先使用初始化列表初试化。
- 成员变量在类中 声明次序,就是在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关。
玩法三:混合初始化列表和函数体内赋值
class Date
{
public:
//混着用
Date(int year = 2020, int month = 1, int day = 1)
: _year(year)
, _month(month)
{
_day = day;
}
private:
int _year;
int _month;
int _day;
};
1.1 关键字explicit
首先看一下这段程序:
class A
{
public:
//没加关键字,转换能发生, A a2 = 2;
A(int a = 0)
:_a(a)
{
cout << "A(int a = 0)" << endl;
}
private:
int _a;
};
int main()
{
A a1(1);//调用构造函数
//含义: 中间产生临时对象 A temp(2) 转换成 A a2(temp)
//编译器优化成,直接调用构造函数
A a2 = 2;//单参数的构造函数,支持类型转化
return 0;
}
运行结果:
再来分析下面代码及图解:
class A
{
public:
//加了关键字,转换不能发生, A a2 = 2;
explicit A(int a = 0)
:_a(a)
{
cout << "A(int a = 0)" << endl;
}
private:
int _a;
};
int main()
{
A a1(1);//调用构造函数
//含义: 中间产生临时对象 A temp(2) 转换成 A a2(temp)
//编译器优化成,直接调用构造函数
A a2 = 2;//单参数的构造函数,支持类型转化
return 0;
}
发现总结:用explicit修饰的构造函数,将禁止单参构造函数的隐式转换
。
2 static成员
用static修饰的成员变量叫做静态成员变量;
用static修饰的成员函数叫做静态成员函数;
注意:静态成员变量一定要在类外进行初始化 。
特性:
- 静态成员为所有类对象所共享,不属于某个具体的实例;
- 静态成员变量必须在类外定义,定义时不必加static关键字修饰;
- 类静态成员即可用类名::静态成员或对象.静态成员来访问;
- 静态成员函数没有隐藏的this指针,不能访问任何非静态成员
- 静态成员和类的普通成员一样,也有公共、保护、私有三种访问级别,也可具有返回值。
class A
{
public:
//构造
A()
{
++_n;
}
//拷贝构造
A(const A& a)
{
++_n;
}
//静态成员函数
static int GetN()
{
return _n;
}
private:
//静态成员变量
//n是存在静态区,属于整个类,也属于类的所有对象
static int _n;//只是声明,不在构造函数初始化,类外全局位置初始化
};
//静态成员变量的初始化
//不受访问限定符限定,
int A::_n = 0;
int main()
{
cout << A().GetN() << endl;
return 0;
}
测试截图:
注:
静态成员函数不可调用非静态成员函数。(静态成员函数无this指针)
非静态成员函数突破类的限制就可以调用类的静态成员函数。
3 C++11的成员初始化
C++11支持非静态成员变量在声明时进行初始化赋值,但是要注意这里不是初始化,这里是给声明的成员变量缺省值。
对于上图中绿色框中三种情况,int _a 和 int * _p 属于声明,对应蓝色框中的两个数字,对应的是声明的成员变量缺省值,不是初始化,初始化在别处写。对应紫色框,是自定义类型,在紫色框处初始化。
4 友元
友元分为友元函数和友元类。
友元提供一种突破封装的方式,虽然会带来访问便利,但是也会增加耦合度,破坏封装。
4.1 友元函数
友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在类的内部声明,声明时需要增加friend关键字。
class Date
{
// 友元函数的声明
friend ostream& operator<<(ostream& out, const Date& d);
friend istream& operator>>(istream& in, Date& d);
public:
//默认构造函数 ,全缺省
Date(int year = 2020, int month = 5, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
// cout << d;
ostream& operator<<(ostream& out, const Date& d)
{
//友元函数使用
out << d._year << "-" << d._month << "-" << d._day << endl;
return out;//返回值保证可以连续输出
}
// cin >> d
//输入的值需要修改,不要再加想out一样的const
istream& operator>>(istream& in, Date& d)
{
in >> d._year >> d._month >> d._day;
return in;
}
int main()
{
Date d1, d2(2022, 10, 29);
cin >> d1 >> d2;
cout << d1 << d2;
return 0;
}
还可以这样玩,小点解释:还可以使用类内的成员函数返回值的方式返回成员变量的值。下面展示一下:
class Date
{
// 友元函数的声明
friend ostream& operator<<(ostream& out, const Date& d);
friend istream& operator>>(istream& in, Date& d);
public:
//默认构造函数 ,全缺省
Date(int year = 2020, int month = 5, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
//传值返回,不能修改,保证封装有意义
int GetYear() const
{
return _year;
}
int GetMonth() const
{
return _month;
}
private:
int _year;
int _month;
int _day;
};
// cout << d;
ostream& operator<<(ostream& out, const Date& d)
{
//使用类内GetYear();GetMonth()
out << d.GetYear()<<" ";//类内函数必须是const的
out << d.GetMonth();//类内函数必须是const的
return out;//返回值保证可以连续输出
}
// cin >> d
//输入的值需要修改,不要再加想out一样的const
istream& operator>>(istream& in, Date& d)
{
in >> d._year>>d._month;
return in;
}
int main()
{
Date d1;
cin >> d1;
cout << d1;
return 0;
}
总结:
- 友元函数可以访问类的私有和保护成员,但不是类的成员函数;
- 友元函数不能用const修饰;
- 友元函数可以在类定义的任何地方声明,不受类访问限定符限制;
- 一个类可有多个类的友元函数;
- 友元函数的调用与普通函数的调用和原理相同。
4.2 友元类
友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员;
class Date; //前置声明
class Time
{
// Date类是Time类的友元类
friend class Date;
public:
Time(int hour=2020, int minute=2, int second=3)
{
_hour = hour;
_minute = minute;
_second = second;
}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
Date(int year = 2020, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
void SetTimeOfDate(int hour, int minute, int second)
{
// 访问Time类私有的成员变量
_t._hour = hour;
_t._minute = minute;
_t._second = second;
}
private:
int _year;
int _month;
int _day;
Time _t;
};
总结:
- 友元类不能传递
- 友元类不具有交换性
5 内部类
一个定义在另一个类的内部,这个在内部的类叫做内部类。
注意:
内部类,是一个独立的类,不属于外部类。
外部类对内部类没有访问权限。
特性:
- 内部类是外部类的友元;
- 内部类可以定义在外部类的任何位置;
- 内部类可以直接访问外部类的static、枚举成员,不需要外部类的对象或类名;
- sizeof测大小,和内部类没关系,即sizeof(外部类)= 外部类;
class A
{
private:
static int k;
int h = 0;
public:
class B
{
public:
void foo(const A& a)
{
cout << k << endl;
cout << a.h << endl;
}
};
};
int A::k = 1;
int main()
{
A aa;
A::B b;//访问方式总结
b.foo(A());
b.foo(aa);
return 0;
}
以上是关于C++类和对象(构造函数static成员内部类友元函数等)的主要内容,如果未能解决你的问题,请参考以下文章
C++初阶:类和对象(下篇)初始化列表 | static成员 | 友元