目录
前言
本文简单介绍C++类和对象。
一、再谈构造函数
在中篇中，我们认识了构造函数，下面我们再谈构造函数
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};这种初始化方式是函数体内初始化
下面介绍一下初始化列表
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个“成员变量”后面跟一个放在括号中的初始值或表达式
class Date
{
public:
explicit Date(int year = 0, int month = 0, int day = 0)
:_year(year)
,_month(month)
,_day(day)
{}
private:
int _year;
int _month;
int _day;
};
上面就是初始化列表的方式初始化成员变量
1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)2. 类中包含以下成员，必须放在初始化列表位置进行初始化：引用成员变量 const成员变量 自定义类型成员(且该类没有默认构造函数时)
自定义类型成员推荐使用初始化列表，初始化列表可以认为是成员变量定义的地方，编译器确定成员变量的定义是从初始化列表来确定的，如果不显示的写初始化列表，走到构造函数时也会经过初始化列表。
class Time
{
public:
Time(int hour)
{
_hour = hour;
}
private:
int _hour;
};
class Date
{
public:
Date(int year = 0, int month = 0, int day = 0)
:_year(year)
,_month(month)
,_day(day)
,_t(200)
{}
private:
Time _t;
int _year;
int _month;
int _day;
}
这时就需要使用初始化列表来初始化_t
如果不使用初始化列表，在函数体内初始化，首先需要定义一个Time类，再调用拷贝构造，来初始化_t，系统开销比较大。如果直接使用初始化列表可以直接调用一次构造函数就可以初始化。
const成员变量和引用成员变量需要使用初始化列表是因为，他们两个在定义时就必须初始化。而初始化列表就是成员变量定义的地方，所以他们两个必须使用初始化列表。
内置类型也比较推荐使用初始化列表，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
初始化列表中也可以调用函数
class A
{
public:
A(int N)
:_a(int*)malloc(sizeof(int)*N)
,_N(N)
{}
private:
int * _a;
int _N;
};但是并不推荐使用这种方式，像_a初始化更适用于函数体内初始化，因为在初始化列表并不能进行合法性检查，判断malloc是否成功，以及在初始化列表调用函数，可读性较差。
class A
{
public:
A(int N)
:_a(int*)malloc(sizeof(int)*N)
,_N(N)
{
if(_a == NULL)
{
perror("malloc");
}
memset(_a, 0, sizeof(int)*N);
}
private:
int* _a;
int N;
}
像这种就比较好
看这样一道题
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
C++构造函数具有：谁先声明，先初始化谁，与初始化列表的先后次序无关，并且谁调用构造函数，定义的就是谁的成员变量
explicit关键字
首先, C++中的explicit关键字只能用于修饰只有一个参数的类构造函数, 它的作用是表明该构造函数是显示的, 而非隐式的,跟它相对应的另一个关键字是implicit, 意思是隐藏的,类构造函数默认情况下即声明为implicit(隐式).
简单来说explicit函数是为了防止隐式类型转换的(用来修饰构造函数）
class Date
{
public:
Date(int year)
:_year(year)
{
cout << "Date(int year)" << endl;
}
private:
int _year;
};
int main()
{
Date d1(2022);
Date d2 = 2022;
return 0;
}我们先看这个简单的例子，d1和d2之间的区别是什么？
d1是十分明显的，直接调用构造函数
d2是构造+拷贝构造+编译器优化——》直接调用构造
2022是一个int类型的变量，d2是一个Date类型的变量，两者将发生隐式类型转换，将2022转换为
Date类型，转化过程中会产生一个Date类型的临时变量，产生临时变量的过程，会调用构造函数
然后将这个临时变量拷贝构造给d2
连续的一个表达式步骤中，连续构造一般都会优化。
如果加上explicit关键字在构造函数之前，就会发生报错：无法从int转换成Date
临时对象，具有很大的意义
例如：
void func(string s)
{
//......
}
string str("insert");
func(str);
func("insert");
我们要调用func函数，如果没有临时对象，我们需要先实例化一个对象str，然后再将str传入func函数，这需要1次构造，1次拷贝构造。如果我们用下面的方式调用func函数，只需要一次构造就可以了。这是经过编译器优化的结果。
例如
class Solution {
public:
int Sum_Solution(int n) {
}
};我们定义这样一个类，并不想要示例化对象，我们只需要调用类内部的函数，我们就可以通过临时对象来解决。
Solution().Sum_Solution(10);调用该类，只是为了调用里面的成员函数，以后也不会再用该类，直接写成匿名对象更简洁。
同时这个匿名对象的生命周期只有一行。
二、Static成员
声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的 成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化
1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制
创建对象一定要调用构造函数，一般构造函数分为两类，构造函数，拷贝构造函数。每次调用构造函数我们就++
#include<iostream>
using namespace std;
//定义一个类，计算出它一共实例化多少对象
class A
{
public:
A()
{
_count++;
}
A(const A& a)
{
_count++;
}
static int GetCount()
{
return _count;
}
private:
static int _count;
};
int A:: _count = 0;
int main()
{
A aa1;
A aa2;
A aa3(aa1);
cout << A::GetCount() << endl;
return 0;
}
设计一个只能在栈上定义的类
#include<iostream>
using namespace std;
class StackOnly
{
public:
static StackOnly CreatObj()
{
StackOnly so;
return so;
}
private:
StackOnly(int x = 0, int y = 1)
:_x(x)
,_y(y)
{}
int _x;
int _y;
};
int main()
{
StackOnly st = StackOnly::CreatObj();
return 0;
}
先看代码，我们将构造函数定义为私有，这样就不能随意调用构造函数了
然后我们再另一个函数中先在栈上实例化一个对象
然后返回该对象的拷贝，就可以了。
又因为我们将构造函数私有了，在main函数我们不能实例化任何对象，所以我们要将该函数定义为static
三、友元
友元比较简单，友元是一种定义在类外部的普通函数或类，但它需要在类体内进行说明，为了与该类的成员函数加以区别，在说明时前面加以关键字friend。友元不是成员函数，但是它可以访问类中的私有成员。
友元分为友元类，和友元函数
友元函数具有以下特点：
友元函数可访问类的私有和保护成员，但不是类的成员函数友元函数不能用const修饰友元函数可以在类定义的任何地方声明，不受类访问限定符限制一个函数可以是多个类的友元函数友元函数的调用与普通函数的调用原理相同
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。友元关系是单向的，不具有交换性。比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。友元关系不能传递如果B是A的友元，C是B的友元，则不能说明C时A的友元。友元关系不能继承
inline ostream& operator<<(ostream& out, const Date& d)
{
out << d._year << "/ " << d._month << "/ " << d._day;
return out;
}
inline istream& operator>>(istream& in, Date& d)
{
cin >> d._year >> d._month >> d._day;
return in;
}我们要尽量少的使用友元和友元类，友元会破坏类的封装性
四、内部类
概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。特性：1. 内部类可以定义在外部类的public、protected、private都是可以的。2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。3. sizeof(外部类)=外部类，和内部类没有任何关系。
class A
{
private:
int _h;
public:
class B
{
private:
int _b;
};
};这就是一个简单的内部类，B可以直接访问_h但是A不可访问_b
如果在A中定义一个静态变量，B可以直接访问，静态成员突破类域就可以访问。
我们以下面题为例，具体讲解内部类的用法
class Solution {
public:
class Sum
{
public:
Sum()
{
_sum += _i;
_i++;
}
};
int Sum_Solution(int n)
{
Sum a[n];
return _sum;
}
private:
static int _sum;
static int _i;
};
int Solution::_sum = 0;
int Solution::_i = 1;
我们定义Sum类是为了利用Sum类的构造函数来进行加法，而Solution类只是为了调用Sum_Solution函数，本质是为了使用_sum和_i这两个静态变量，又因为Sum是Solution类的内部类，可以访问Solution中全部的数据，Solution无法访问Sum类中的成员，所以将_sum和_i定义在外面。
总结
以上就是今天要讲的内容，本文仅仅简单介绍了类和对象，类和对象中还有其它细节。
1262
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
