类的定义
目录
1.面向过程和面向对象初步认识
2.类的引入
3.类的定义
4.类的访问限定符及封装
4.1 访问限定符
4.2 封装
5.类的作用域
6.类的实例化
7.类对象模型
7.1 如何计算类对象的大小
7.2 类对象的存储方式猜测
8.this指针
8.1 this指针的引出
8.2 this指针的特性
8.3 C语言和C++实现Stack的对比
1.面向过程和面向对象初步认识
C语言是面向过程的,关注的是过程,分析出求解问题的步骤,通过函数调用逐条解决问题.
C++是基于面向对象的,关注的是对象,将一件事情拆分成不同的对象,靠对象之间的交互完成.
2.类的引入
c语言结构体中只能定义变量,在C++中,结构体不仅可以定义变量,也可以定义函数.比如:之前在数据结构初阶中,用C语言方式实现的栈,结构体只能定义变量,现在以C++方式实现,会发现struct中也可以定义函数
struct Stack
{
void Init(size_t capacity)
{
_array = (DataType*)malloc(sizeof(DataType) * capacity);
if (nullptr == _array)
{
perror("malloc申请空间失败");
return;
}
_capacity = capacity;
_size = 0;
}
void Push(const DataType& data)
{
_array[_size] = data;
++_size;
}
DataType Top()
{
return _array[_size - 1];
}
void Destory()
{
if (_array)
{
free(_array);
_array = nullptr;
_capacity = 0;
_size = 0;
}
}
DataType* _array;
size_t _capacity;
size_t _size;
};
int main()
{
Stack s;
s.Init(10);
s.Push(1);
s.Push(2);
s.Push(3);
cout << s.Top() << endl;
s.Destory();
return 0;
}上面结构体的定义,在C++中更喜欢用class来代替
3.类的定义
class className
{
//类体:由成员函数和成员变量组成
}; //一定要注意后面的分号class为定义类的关键字,classname为类的名字,{}中为类的主体,注意类定义结束时后面分号不能省略
类体中的内容为类的成员:类中的变量称为类的属性或成员变量;类中的函数称为类的方法或者成员函数.
类的两种定义方式:
- 声明和定义全部放在类体中,需注意:成员函数如果在类中定义,编译器可能会将其当成内联函数处理.
- 类声明放在.h文件中,成员函数放在.cpp文件中,需注意:成员函数名前需要加类名
一般情况下,更期望采用第二种方式.
成员变量命名规则的建议:
//我们看看这个函数,是不是很僵硬?
class Date
{
public:
void Init(int year)
{
//这里的year到底时成员变量,还是函数形参?
year = year;
}
private:
int year;
};
//所以一般都建议这样
class Date
{
public:
void Init(int year)
{
_year = year;
}
private:
int _year;
};
//或者这样
class Date
{
public:
void Init(int year)
{
mYear = year;
}
private:
int mYear;
};4.类的访问限定符及封装
4.1 访问限定符
C++实现封装的方式:用类将对象的属性与方法结合在一起,让对象更加完善,通过访问权限选择性的将其接口提供给外部的用户使用.
[访问限定符说明]
- public修饰的成员在类外可以直接被访问
- protected和private修饰的成员在类外不能直接被访问
- 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现为止
- 如果后面没有访问限定符,作用域就到 } 即类结束
- class的默认访问权限为private, struct为public
注意:访问限定符只在编译时有用,当数据映射到内存后,没有任何访问限定符上的区别
4.2 封装
面向对象的三大特性:封装,继承,多态
在类和对象阶段,主要时研究类的封装特性,那什么是封装呢?
封装: 将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口和对象进行交互.封装本质上是一种管理,让用户更方便使用类.
在C++语言中实现封装,可以通过类将数据以及操作数据的方法进行有机结合,通过访问限定来隐藏对象内部实现细节,控制哪些方法在类外部直接被使用.
5.类的作用域
类定义了一个新的作用域,类的所有成员都在类的作用域中.在类体外定义成员时,需要 :: 作用域操作符指明成员属于哪个类域.
class Person
{
public:
void PrintPersonInfo();
private:
char _name[20];
char _gender[3];
int _age;
};
//这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
cout << _name << " " << _gender << " " << _age << endl;
}6.类的实例化
用类类型创建对象的过程,称为类的实例化
- 类是对对象进行描述的,是一个模型一样的东西,限定了类有哪些成员,定义出一个类并没有分配实际的内存空间来存储它;
- 一个类可以实例化出多个对象,实例化出的对象 占用实际的物理空间,存储成员变量
int main() { Person._age = 100; // 编译失败：error C2059: 语法错误:“.” return 0; }Person类是没有空间的,只有Person类实例化出的对象才有具体的年龄
7.类对象模型
7.1 如何计算类对象的大小
class A
{
public:
void PrintA()
{
cout << _a << endl;
}
private:
char _a;
};问题:类中既可以有成员变量,又可以有成员函数,那么一个类的对象包含了什么?如何计算一个类的大小?
7.2 类对象的存储方式猜测
- 对象中包含类的各个成员
缺陷:每个对象中成员变量是不同的,但是调用同一份函数,如果按照此种方式存储,当一个类创建多个对象时,每个对象中都会保存一份代码,相同代码保存多次,浪费空间
- 代码中保存一份,在对象中保存存放代码的地址
- 只保存成员变量,成员函数存放在公共的代码段
问题:对于上述三种存储方式,那计算机到底是按照哪种方式来存储的?
我们在通过对下面的不同对象分别获取大小来分析看下
//类中既有成员变量,又有成员函数
class A1 {
public:
void f1(){}
private:
int _a;
};
//类中仅有成员函数
class A2 {
public:
void f2(){}
};
//类中什么都没有---空类
class A3
{};
int main()
{
cout << sizeof(A1) << endl;
cout << sizeof(A2) << endl;
cout << sizeof(A3) << endl;
return 0;
}sizeof(A1):4 sizeof(A2):1 sizeof(A3):1
结论:一个类的大小,实际就是该"成员变量"之和,当然要注意内存对齐
注意空类的大小,空类比较特殊,编译器给了空类一个字节来唯一标识这个类的对象
8.this指针
8.1 this指针的引出
我们先来定义一个日期类Date
class Date
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
int a;
};
int main()
{
Date d1, d2;
d1.Init(2022, 1, 11);
d2.Init(2022, 1, 12);
d1.Print();
d2.Print();
return 0;
}对于上述类,有这样的一个问题:
Date类中有Init与Print两个成员函数,函数体中没有关于不同对象的区分,那当d1调用Init函数时,该函数是如何知道应该设置d1对象,而不是d2对象的?
C++通过引入this指针解决该问题,即:C++编译器给每个"非静态的成员函数"增加了一个隐藏的指针参数,让该指针指向当前对象(函数运行时调用该函数的对象),在函数体中所有"成员变量"的操作,都是通过该指针去访问.只不过所有的操作对用户是透明的,即用户不需要来传递,编译器自动完成
8.2 this指针的特性
- this指针的类型:类类型* const,即成员函数中,不能给this指针赋值
- 只能在"成员函数"的内部使用
- this指针本质上是"成员函数"的形参,当对象调用成员函数时,将对象地址作为实参传递给this形参.所以对象中不存储this指针.
- this指针是"成员函数"第一个隐含的指针形参,一般情况由编译器通过ecx寄存器自动传递,不需要用户传递
8.3 C语言和C++实现Stack的对比
1.C语言实现
typedef int DataType;
typedef struct Stack
{
DataType* array;
int capacity;
int size;
}Stack;
void StackInit(Stack* ps)
{
assert(ps);
ps->array = (DataType*)malloc(sizeof(DataType) * 3);
if (NULL == ps->array)
{
assert(0);
return;
}
ps->capacity = 3;
ps->size = 0;
}
void StackDestroy(Stack* ps)
{
assert(ps);
if (ps->array)
{
free(ps->array);
ps->array = NULL;
ps->capacity = 0;
ps->size = 0;
}
}
void CheckCapacity(Stack* ps)
{
if (ps->size == ps->capacity)
{
int newcapacity = ps->capacity * 2;
DataType* temp = (DataType*)realloc(ps->array,
newcapacity*sizeof(DataType));
if (temp == NULL)
{
perror("realloc申请空间失败!!!");
return;
}
ps->array = temp;
ps->capacity = newcapacity;
}
}
void StackPush(Stack* ps, DataType data)
{
assert(ps);
CheckCapacity(ps);
ps->array[ps->size] = data;
ps->size++;
}
int StackEmpty(Stack* ps)
{
assert(ps);
return 0 == ps->size;
}
void StackPop(Stack* ps)
{
if (StackEmpty(ps))
return;
ps->size--;
}
DataType StackTop(Stack* ps)
{
assert(!StackEmpty(ps));
return ps->array[ps->size - 1];
}
int StackSize(Stack* ps)
{
assert(ps);
return ps->size;
}
int main()
{
Stack s;
StackInit(&s);
StackPush(&s, 1);
StackPush(&s, 2);
StackPush(&s, 3);
StackPush(&s, 4);
printf("%d\n", StackTop(&s));
printf("%d\n", StackSize(&s));
StackPop(&s);
StackPop(&s);
printf("%d\n", StackTop(&s));
printf("%d\n", StackSize(&s));
StackDestroy(&s);
return 0;
}
可以看到,在用C语言实现时,Stack相关操作有以下共性:
- 每一个函数的第一个参数都是Stack*
- 函数中必须要对第一个参数检测,因为该参数可能为NULL
- 函数中都是通过Stack*参数操作栈的
- 调用时必须传递Stack结构体变量的地址
结构体中只能定义存放数据的结构,操作数据的方法不能放在结构体中,即数据和操作数据的方式是分离开的,而且实现上相当复杂一些,涉及大量指针操作,稍不注意可能就会出错
2.C++实现
class Stack
{
public:
void Init(int capacity = 3)
{
_array = (DataType*)malloc(sizeof(DataType*) * capacity);
if (_array == nullptr)
{
perror("malloc fail!");
return;
}
_capacity = capacity;
_size = 0;
}
void Destory()
{
free(_array);
_array = nullptr;
_capacity = _size = 0;
}
void Push(DataType data)
{
CheckCapacity();
_array[_size] = data;
_size++;
}
bool Empty()
{
return _capacity == 0;
}
void Pop()
{
if (Empty())
return;
_size--;
}
DataType Top()
{
return _array[_size - 1];
}
private:
void CheckCapacity()
{
if (_size == _capacity)
{
int newcapacity = _capacity * 2;
DataType* tmp = (DataType*)realloc(_array, sizeof(DataType) * newcapacity);
if (tmp == nullptr)
{
perror("realloc fail!");
}
_array = tmp;
_capacity = newcapacity;
}
}
DataType* _array;
int _capacity;
int _size;
};
int main()
{
Stack s;
s.Init();
s.Push(1);
s.Push(2);
s.Push(3);
s.Push(4);
s.Push(5);
cout << s.Top() << endl;
return 0;
}C++中通过类可以将数据以及操作数据的方法进行完美结合,通过访问权限可以控制哪些方法在类外可以被调用,即封装,在使用时就像使用自己的成员一样,而且每个方法不需要传Stack*的参数了,编译器编译之后该参数会自动还原,编译器编译之后该参数会自动还原,即C++中Stack* 参数时编译器维护的,C语言中需要用户自己维护.