目录
前言
一、再谈构造函数
二、Static成员
三、友元
四、内部类
总结
前言
本文简单介绍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 访问限定符的限制
static修饰的变量和函数是属于整个类的,我们可以直接通过类名获取到static修饰的变量和函数(前提是定义为public)
static修饰的内容可以通过该类的某一个对象来读取,也可通过类名读取。
因为是属于整个类,所以自然是没有this指针,也就无法访问非静态成员。
面试题:实现一个类,计算程序中创建出了多少个类对象。
初看这道题,我们可能会想到利用全局变量,来统计个数,可是全局变量没有封装性,谁都可以修改,无法保证数据的真实性,我们就想到了利用static
创建对象一定要调用构造函数,一般构造函数分为两类,构造函数,拷贝构造函数。每次调用构造函数我们就++
#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可以直接访问,静态成员突破类域就可以访问。
我们以下面题为例,具体讲解内部类的用法
求1+2+3+...+n_
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定义在外面
总结
以上就是今天要讲的内容,本文仅仅简单介绍了类和对象,类和对象中还有其它细节。