C++:渴望力量吗,少年?
文章目录
一、初始化列表
在构造函数中,以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个"成员变量"后面跟一个放在括号中的初始值或表达式。
【注意】
(1)每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)。
(2)类中包含以下成员,必须放在初始化列表位置进行初始化:
a. 引用成员变量
b. const成员变量
c. 没有默认构造函数的自定义类型成员
(3)尽量使用初始化列表初始化,因为不管你是否使用初始化列表,对于自定义类型成员变量, 一定会先使用初始化列表初始化。
(4)成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关。
(下面的代码比较长,是对上述内容的实现)
typedef int DataType;
class Stack
{
public:
//Stack(size_t capacity)
//{
// cout << "Stack()" << endl;
// _array = (DataType*)malloc(sizeof(DataType) * capacity);
// if (NULL == _array)
// {
// perror("malloc申请空间失败!!!");
// return;
// }
// _capacity = capacity;
// _size = 0;
//}
Stack(size_t capacity)//把上面的代码改成下面这段,这段代码就是初始化列表和函数体的混合使用
:_array((DataType*)malloc(sizeof(DataType) * capacity))
,_size(0)
,_capacity(capacity)
{
cout << "Stack()" << endl;
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}
memset(_array, 0, sizeof(DataType) * _capacity);
}
// s1(s)
Stack(const Stack& s)
{
cout << "Stack(Stack& s)" << endl;
// 深拷贝
_array = (DataType*)malloc(sizeof(DataType) * s._capacity);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}
memcpy(_array, s._array, sizeof(DataType) * s._size);
_size = s._size;
_capacity = s._capacity;
}
Stack& operator=(const Stack& st)
{
if (this != &st)
{
// ...
}
return *this;
}
void Push(DataType data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
~Stack()
{
cout << "~Stack()" << endl;
free(_array);
_array = nullptr;
_size = _capacity = 0;
}
private:
// 内置类型
DataType* _array;
int _capacity;
int _size;
};
class MyQueue
{
public:
MyQueue(int capacity = 10)
:_st1(capacity)
,_st2(capacity)
{}
private:
Stack _st1;
Stack _st2;
};
class A
{
public:
A(int a = 0)
:_a(a)
{}
private:
int _a;
};
class Date
{
public:
// 初始化列表是每个成员定义的地方,不管你写不写,每个成员都要会在初始化列表定义
// 编译器对不写在初始化列表的内置类型用随机值初始化,对自定义类型会去调用其默认构造函数(可以在监视窗口看出)
// 如果在初始化列表已经初始化,并且也在默认构造函数使用了缺省参数,那么以初始化列表的为主
Date(int year, int month, int day, int& i)//从下面可以看出来初始化列表和在函数体里面赋值可以混合使用
: _year(year)
, _month(month)
,_a(1)
,_refi(i)
//,_x(1) //这句话不能写在下面的函数体,因为const修饰的变量要在定义时初始化
{
// 这里已经不算初始化列表了,算赋值
_day = day;
}
void func()
{
++_refi;
++_refi;
}
private://注意下面的变量全部只是声明,在定义的时候是按照变量声明的顺序走的
int _year;
int _month = 1;
int _day = 1;
// C++11支持给缺省值,这个缺省值是给初始化列表的
// 如果初始化列表没有显式给值,就用这个缺省值
// 如果显式给值了,就不用这个缺省值
// 下面的变量必须在定义时初始化
const int _x = 10;
int& _refi;
A _a;
};
//能用初始化列表就用初始化列表
//有些场景还是需要初始化列表和函数体混着用
int main()
{
//MyQueue mq;
int n = 0;
Date d1(2023, 7, 28, n);
d1.func();
cout << n << endl;
return 0;
}
二、explicit关键字、匿名对象
1. explicit关键字
构造函数不仅可以构造与初始化对象,还具有类型转换的作用。用explicit修饰构造函数,将会禁止构造函数的隐式转换。
2. 匿名对象
以上内容在下面的代码中可以得到体现:
class A
{
public:
explicit A(int i)//explicit关键字可以阻止单/多参数构造函数的隐式类型转换
//A(int i)
:_a(i)
{
cout << "A(int i)" << endl;
}
A(const A& aa)
:_a(aa._a)
{
cout << "A(const A& aa)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
class B
{
public:
B(int b1, int b2)
//explicit B(int b1, int b2)
:_b1(b1)
, _b2(b2)
{
cout << "B(int b1, int b2)" << endl;
}
private:
int _b1;
int _b2;
};
struct SeqList
{
public:
void PushBack(const A& x)
{
// ... 扩容
_a[_size++] = x;
}
size_t size() const
{
return _size;
}
// 读
const A& operator[](size_t i) const
{
assert(i < _size);
return _a[i];
}
// 读/写
A& operator[](size_t i)
{
assert(i < _size);
return _a[i];
}
private:
// C++11
A* _a = (A*)malloc(sizeof(A) * 10);
size_t _size = 0;
size_t _capacity = 0;
};
class Solution {
public:
int Sum_Solution(int n) {
// ...
return n;
}
private:
};
int main()
{
//A aa1(1);
//A aa2 = 2;// 单参数构造函数的隐式类型转换
正常的步骤是用int类型的2调用A的构造函数生成一个临时对象,再用这个对象去拷贝构造aa2
但是一般编译器会再优化,优化为用2直接构造
//上面的两个语句结果都是等价的,但是实现的过程不一样
//const A& ref1 = 2;//不加上const就无法编译,因为按照上一条语句,类型转换会先生成临时对象,而临时对象具有常属性,把int类型赋值给常属性属于权限放大
/*SeqList s;
A aa3(3);
s.PushBack(aa3);
//上面的两个语句也可以被下面更加简洁的语句替代,之所以可以是因为的单参数构造函数的隐式类型转换
s.PushBack(4);
double d = 1.1;
int i = d;//这个语句是对的,但是下面的语句不加上const就是错的,因为类型转换会生成临时对象,临时对象具有常属性,不加上const是权限的放大
const int& j = d;*/
// C++11 也支持多参数的隐式类型转换
B bb1(1, 1);
B bb2 = { 2, 2 };//注意要用花括号
const B& ref2 = { 3,3 };
// 有名对象 特点:生命周期在当前局部域,该语句结束之后还可以使用aa6
A aa6(6);
// 匿名对象 特点:生命周期只在这一行
A(7);//没有其他地方可以使用这个对象,在这里调用完就直接析构了
SeqList s;
A aa7(7);
s.PushBack(aa7);
s.PushBack(A(8));//匿名对象
Solution sl;
sl.Sum_Solution(10);
Solution().Sum_Solution(100);//匿名对象
//Date d1(2023, 7, 28);
//cout << d1;
//cout << Date(2023, 7, 28);
return 0;
}
三、static成员
1. 概念
声明为static的类成员称为类的静态成员,用static修饰的成员变量,称之为静态成员变量;用static修饰的成员函数,称之为静态成员函数。静态成员变量一定要在类外进行初始化。
2. 特性
(1)静态成员为所有类对象所共享,不属于某个具体的对象,存放在静态区。
(2)静态成员变量必须在类外定义,定义时不添加static关键字,类中只是声明。
(3)类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问。
(4)静态成员函数没有隐藏的this指针,不能访问任何非静态成员。
(5)静态成员也是类的成员,受public、protected、private 访问限定符的限制。
四、友元
友元提供了一种突破封装的方式,有时提供了便利。但是友元会增加耦合度,破坏了封装,所以友元不宜多用。
友元分为:友元函数和友元类。
1. 友元函数
(1)友元函数可访问类的私有和保护成员,但不是类的成员函数。
(2)友元函数不能用const修饰。
(3)友元函数可以在类定义的任何地方声明,不受类访问限定符限制。
(4)一个函数可以是多个类的友元函数。
(5)友元函数的调用与普通函数的调用原理相同。
2. 友元类
友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员。
(1)友元关系是单向的,不具有交换性。
比如上述Time类和Date类,在Time类中声明Date类为其友元类,那么可以在Date类中直接访问Time类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行。
(2)友元关系不能传递。
如果C是B的友元, B是A的友元,则不能说明C时A的友元。
(3)友元关系不能继承,在继承位置再给大家详细介绍。
下面是友元类的用法,友元函数的用法也是类似的。
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. 概念
如果一个类定义在另一个类的内部,这个在里面的类就叫做内部类。内部类是一个独立的类, 它不属于外部类,更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
注意:内部类就是外部类的友元类,参见友元类的定义,内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
2. 特性
(1)内部类可以定义在外部类的public、protected、private都是可以的。
(2)注意内部类可以直接访问外部类中的static成员,不需要外部类的对象/类名。
(3)sizeof (外部类) = 外部类,和内部类没有任何关系。
class A
{
public:
class B//默认B是A的友元类,所以B里面可以使用A的私有成员,但是反过来是不可以的
{
public:
void FuncB()
{
A aa;
aa._a = 1;
}
private:
int _b;
};
void func()
{
B bb;
//bb._b = 1;
}
private:
int _a;
};
int main()
{
cout << sizeof(A) << endl;
A aa;
//B bb;//未加 A::
A::B bb1;//如果内部类B不是public的话,那就不可以这样访问
return 0;
}
总结
类与对象的基础知识大概就掌握这些,接下来我们会更加深入地学习并使用它们。