文章目录
1、认识面向过程和面向对象
C++作为C语言的扩展，C语言是面向过程的，关注的是过程，一个函数接着一个函数逐步解决问题，而C++是面向对象的，将一件事拆分为多个对象，关注对象之间的交互。
比如，你做饭的时候，C语言实现的是你这一步和下一步需要做什么，而C++关注是你、电饭煲、油烟机、电磁炉等等之间的交互，我们人不需要关注电饭煲是如何运作的等等。
我们先大概认识面向对象和面向过程是什么，深刻的理解还得经过我们不断的使用去感悟。
2、类的引入
C++作为C的拓展，所以C++中也有结构体，C++的结构体不同于C的结构体，C的结构体只能定义成员变量，而C++除了可以定义成员变量也可以定义成员函数。
比如：
struct stack
{
// 成员函数/成员方法
//void StackInit(size_t capacity)
//{}
void Init(size_t capacity)
{}
//void StackDestroy()
//{}
void Destroy()
{}
// 成员变量
DataType* _array;
size_t _capacity;
size_t _size;
};
只不过在C++中定义结构体更喜欢用class来代替，所以也有了类。
3、类的定义
首先认识几个概念:
- 类里的内容称作类的成员。
- 类里定义的变量称作类的属性或成员变量
- 类里的函数称作类的方法或成员函数
定义：
class className
{
//类体：由成员方法和成员变量组成
};// 有分号
定义方式：
1.如果方法的声明和定义都放在类体中，编译器可能会将类的方法当作内联函数处理
class Test
{
//可能当作内联函数处理
void func1()
{
cout << "C++" <<endl;
}
int e1;
int e2;
int e3;
};
2.如果方法定义在类体外，需要在成员函数名前添加类名::
class Test
{
int e1;
int e2;
int e3;
};
//需要在成员函数名前添加类名::
void Test::func1()
{
cout << "C++" <<endl;
}
还一个注意的是，属性命名建议加一些标识（原因为了区分，这里我使用_）
class Test
{
void func1()
{
cout << "C++" <<endl;
}
//加标识为的就是区分
void func2(int e1 = 1, int e2 = 2, int e3 = 3)
{
_e1 = e1;
_e2 = e2;
_e3 = e3;
}
int _e1;
int _e2;
int _e3;
};
4、访问限定符和封装
4.1 访问限定符
类中访问限定符有public(公有)、protected(保护)、private(私有)。
【说明】
- public修饰 的成员在类外可以被直接访问。
- protected和private修饰的成员在类外不能直接被访问(这里两种都一样)。
- 访问权限作用域从该访问限定符出现到下一个访问限定符出现为止。
- 如果后面没有访问限定符，作用域到 } 为止。
- class的默认访问权限为private，struct为public。
一般成员变量都用私有修饰
class Test
{
public:
void func1()
{
cout << "C++" <<endl;
}
void func2(int e1 = 1, int e2 = 2, int e3 = 3)
{
_e1 = e1;
_e2 = e2;
_e3 = e3;
}
private:
int _e1;
int _e2;
int _e3;
};
以下两种情况的成员都是公有修饰
情况一:
struct Test
{
void func1()
{
cout << "C++" <<endl;
}
//加标识为的就是区分
void func2(int e1 = 1, int e2 = 2, int e3 = 3)
{
_e1 = e1;
_e2 = e2;
_e3 = e3;
}
int _e1;
int _e2;
int _e3;
};
情况二:
class Test
{
public:
void func1()
{
cout << "C++" <<endl;
}
//加标识为的就是区分
void func2(int e1 = 1, int e2 = 2, int e3 = 3)
{
_e1 = e1;
_e2 = e2;
_e3 = e3;
}
int _e1;
int _e2;
int _e3;
};
4.2 封装(对比C语言)
C语言中，结构体只能定义成员变量，定义的函数和结构体数据是分开的，函数和数据都可以独立调用
比如我们在学习的C语言栈
typedef int STDataType;
typedef struct stack
{
STDataType* a;
int top;
int capacity;
}ST;
void StackInit(ST* ps)
{
assert(ps);
ps->a = NULL;
ps->capacity = ps->top = 0;
}
void StackDestroy(ST* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->capacity = ps->top = 0;
}
int main() {
ST st;
//可以直接调用数据
st.a = NULL;
//也可以通过函数调用数据
StackInit(&st);
StackDestroy(&st);
return 0;
}
C++中，数据和方法放在一起，并且因为限定符的存在，如果想要增删查改数据就必须通过方法调用，不能直接访问到数据。这就使得数据更好管理和安全。
class stack
{
public:
void Init()
{
_a = NULL;
_capacity = _top = 0;
}
void Destroy()
{
free(_a);
_a = NULL;
_capacity = _top = 0;
}
private:
int* _a;
int _top;
int _capacity;
};
综上:
将成员与方法结合，这是一种封装行为，一种更好管理的行为，通过隐藏成员属性和方法的具体实现，仅对外公开接口来和对象进行交互的行为。
补充:
C++在方法的写法上相比C语言更加简便，C++因为成员和方法的结合，方法不需要类中成员的传参，可以直接使用，并且不需要在名称上做特别的修饰（比如C语言为了更好分辨是StackInit，C++可直接写Init）。
5、类的实例化(对象)
当一个类写出来，是一个类型（类类型），是一个虚拟的（类似建筑图纸），没有占用物理空间，只有通过创建一个对象，才会占用物理空间。
比如：
#include <iostream>
using std::cout;
using std::endl;
class Test
{
public:
void func1()
{
cout << "C++" <<endl;
}
void func2(int e1 = 1, int e2 = 2, int e3 = 3)
{
_e1 = e1;
_e2 = e2;
_e3 = e3;
}
int _e1;
int _e2;
int _e3;
};
int main()
{
//Test._e2 = 2; //err 没有实例化不能修改
Test t1; //创建对象
t1._e1 = 10; //可以修改
return 0;
}
6、类的大小计算
类的成员变量和结构体的算法一样（需要注意结构体对齐），但是类中是否需要计算成员方法的大小呢？
看看代码运行结果
#include <iostream>
using std::cout;
using std::endl;
class Test
{
public:
void func1(int e1 = 1, int e2 = 2, int e3 = 3)
{
_e1 = e1;
_e2 = e2;
_e3 = e3;
}
void func2()
{
cout << _e1 <<endl;
cout << _e2 <<endl;
cout << _e3 <<endl;
}
private:
int _e1;
int _e2;
int _e3;
};
int main()
{
Test t1; //创建对象
cout << sizeof(t1) << endl; //输出12
return 0;
}
可以看到，输出12正好就是3个int对齐计算的结果，所以计算类的大小不用计算方法。
那么具体是怎么样的呢?
实际在C++中，当创建一个对象，对象只存储成员变量，而成员方法通过一个类成员函数表放在公共的代码区。
类似小区中每家每户有独立的空间（存储变量）和可以公共使用的球场（方法）。
7、this指针的存在和特性
先看之前的一个问题
我们知道不能直接通过类去引用成员变量，因为类没有实例化对象，
但是为什么不能引用方法呢？方法明明不存在对象中啊？
#include <iostream>
using std::cout;
using std::endl;
class Test
{
public:
void func1(int e1 = 1, int e2 = 2, int e3 = 3)
{
_e1 = e1;
_e2 = e2;
_e3 = e3;
}
void func2()
{
cout << _e1 <<endl;
cout << _e2 <<endl;
cout << _e3 <<endl;
}
int _e1;
int _e2;
int _e3;
};
int main()
{
//Test._e2 = 2; //err 没有实例化不能修改
//Test.func2(); //为什么err?
Test t1; //创建对象
t1._e1 = 10; //可以修改
return 0;
}
答案：因为编译器会在处理函数的时候添加一个隐藏的this指针，哪个对象调用就把谁传给this指针，因为没有对象，所以没有东西传给this指针，也就报错了。
实际上:
#include <iostream>
using std::cout;
using std::endl;
class Test
{
public:
void func1(int e1 = 1, int e2 = 2, int e3 = 3)
{
_e1 = e1;
_e2 = e2;
_e3 = e3;
}
//void func2()
//{
// cout << _e1 << endl;
// cout << _e2 << endl;
// cout << _e3 << endl;
//}
void func2()
{
cout << this->_e1 << endl;
cout << this->_e2 << endl;
cout << this->_e3 << endl;
}
int _e1;
int _e2;
int _e3;
};
int main()
{
//Test._e2 = 2; //err 没有实例化不能修改
//Test.func2(); //为什么err?
Test t1; //创建对象
t1._e1 = 10; //可以修改
return 0;
}
关于this指针的特性:
- this指针的类型是 类* const。
- this指针只能在成员函数内部使用。
- this指针本质是成员函数的形参，存储在栈区，当对象调用函数，将对象地址作为实参传给this指针。
- this指针是函数隐含的参数，一般由编译器通过寄存器ecx自动传递，不需要用户操作。
下面看一个问题
以下两个函数调用分别是什么情况？
class A
{
public:
void Print()
{
cout << "Print()" << endl;
}
void PrintA()
{
cout<<_a<<endl;
}
private:
int _a;
};
int main()
{
A* p = nullptr;
p->Print();
p->PrintA();
return 0;
}
几个关键点：
- 对空指针解引用程序是会崩溃的。
- 由于方法不存在对象中，如果通过对象调用方法，是不发生解引用的，正常调用代码段。
所以Print正常调用，PrintA调用程序崩溃。
本章完~