目录

  • 一.面向过程和面向对象的初步认识
  • 二.类的引入
  • 三.类的定义
  • 四.类的访问限定符及封装
    • 1.访问限定符
    • 2.封装
  • 五.类的作用域
  • 六.类的实例化
  • 七.类对象模型
    • 1.类对象大小的计算
    • 2.类对象存储方式的猜测
      • (1)猜测一
      • (2)猜测二
      • (3)猜测三
    • 3.结构体内存对齐规则
  • 八.类成员函数的this指针
    • 1.概念引入
    • 2.this指针的特性
    • 3.C语言和C++语言实现栈的对比

一.面向过程和面向对象的初步认识

C语言是面向过程的，关注的是过程，分析出问题的步骤，通过函数调用逐步解决问题。
比如生活中洗衣服这个问题，在C语言的处理下会变成一下多项步骤：拿盆子，放水，放衣服，放洗衣粉，手搓，换水，放洗衣粉，手搓，拧干，晾衣服。
C++语言是面向对象的，关注的是对象，将一个事情拆分成不同的对象，靠对象之间的完成。
比如同样的生活中洗衣服这个问题，参与解决该问题对象总共有四个：人、衣服、洗衣粉、洗衣机。整个洗衣服的过程中，人将衣服放进洗衣机中，倒入洗衣粉，启动洗衣机，洗衣机就会洗衣过程。整个过程主要是人、衣服、洗衣粉、洗衣机之间交互完成的，人不需要关心洗衣机具体是如何完成如何洗衣的。

二.类的引入

C语言结构体中只能定义变量，在C++语言中，结构体不仅仅可以定义变量，还可以定义函数。比如：之前在数据结构中学过用C语言实现的栈，结构体只能定义变量。现在以C++方式实现，会发现struct中可以定义函数。(C++语言兼容C语言的语法)
下面举例说明：

typedef int DataType;
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 Destroy() 
  {
    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.Destroy();
  return 0;
}

上述代码的具体解释：上述代码定义了C++语言结构体Stack，里面有成员函数和成员变量。但是在C++中，常常用class代替struct关键字。

三.类的定义

class className
{
  // 类体：由成员函数和成员变量组成
};  // 一定要注意后面的分号

class为定义类的关键字，className为类的名字，大括号里的内容为主体，注意定义结束后会有个分号。
类体中的内容称为类的成员：类中的变量称为类的属性或成员变量。类中的函数称为类的方法或者成员函数。
类的两种定义方法：

//声明和定义全部放在类体中
class Person
{
 public:
   void showlnfo()
   {
   cout<<_name<<"_"<<_sex<<"_"<<_age<<end1;
   }
 public:
   char *_name;
   char *_sex;
   int _age;
};

//类声明放在.h头文件中，成员函数定义放在.cpp文件中
//person.h文件
class Person
{
 public :
   void showlnfo();
 public :
   char *_name;
   char *_sex;
   int _age;
};
//person.cpp文件
# include "person.h"
void Person::showlnfo()
{
  cout<<_name<<"_"<<_sex<<"_"<<_age<<end1;
}

上述代码的具体解释：类的定义应该严格遵从对应正确的语法结构。一般情况下，建议采用第二种方式。

四.类的访问限定符及封装

1.访问限定符

C++实现封装的方式：用类将对象的属性和方法结合在一起，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。
访问限定符的说明：

  1. public修饰的成员在类外可以直接被访问。
  2. protect和private修饰的成员在类外不能直接被访问(此处的protect和private是类似的)
  3. 访问权限作用域从该访问限定符出现的位置开始到下一个访问限定符出现为止。
  4. 如果后面没有访问限定符，作用域到下一个大括号终止。
  5. class的默认访问权限为private，struct的默认访问权限为public(因为C++语言要兼容C语言的特性)

注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别。
问题：C++中struct和class的区别？
回答：C++需要兼容C语言，所以C++中struct可以当做结构体使用，另外C++中struct也可以用来定义类，和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private，注意：在继承和模版参数列表位置，struct和class也有区别，后续再详细说明。

2.封装

问题：面向对象的三大特性：封装、继承、多态。
在类和对象阶段，我们先研究类的封装特性。
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口和对象进行交互。
封装本质上是一种管理，让用户更加方便使用类。比如：对于电脑这样一个复杂的设备，提供给用户的只有开关机键，通过键盘输入、显示器、USB插孔等，让用户可以和计算机进行交互，完成日常事务，但是实际上电脑真正工作的是CPU、显卡、内存等一些硬件原件。
对于计算机使用者来说，不用关心内部的核心部件，比如主板的布局是什么样的？CPU内部是如何设计的等。用户只需要知道怎么开机，怎么通过键盘和鼠标与计算机进行交互就可以。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。
在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现的细节，控制哪些方法可以在类外部直接被使用。

五.类的作用域

类定义了一个新的作用域，类的所有成员在类的作用域中。在类体外定义成员时。需要使用::，作用域操作符指明成员属于哪个类域。

class Person
{
 public:
   void PrintPersonInfo();
 private:
   char _name[20];
   char _gender[3];
   int  _age;
 };
 // 这里需要指定PrintPersonInfo是属于Person这个类域
 void Person::PrintPersonInfo()
 {
 cout << _name << " "<< _gender << " " << _age << endl;
 }

六.类的实例化

用类类型创建对象的过程中，称为类的实例化。

  1. 类是对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它。
  2. 一个实例可以实例化出多个对象，实例化出的对象，占用实例的物理空间，存储类成员变量。
  3. 做个比方，类实例化出对象就像现实中使用建筑设计的图纸建造房子一样。类就是设计图，只设计出需要什么东西，但是没有实体化的建筑存在，同样也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。
int main()
{
  person._age = 100;//编译错误，语法错误“.”
  return 0;
}

person类是没有空间的，只有person类实例化出的对象才有具体的年龄。

七.类对象模型

1.类对象大小的计算

class A
{
 public:
   void PrintA()    
  {
    cout<<_a<<endl;
  }
 private:
   char _a;
 };

问题：类中既可以有成员变量，又可以有成员函数，那么一个类的对象包含了什么？如何计算一个类的大小？

2.类对象存储方式的猜测

(1)猜测一

对象中包含各类的各个成员
存储方式
缺陷：每个对象中成员变量是不同的，但是会调用相同的成员函数。如果按照此种方式存储，当一个类创建多个对象时，每个对象都会保存一份相同的成员函数代码，相同代码(成员函数相同)保存多次，浪费空间，那么如何解决呢？

(2)猜测二

代码只保存一份，在对象中保存存放代码的地址
存储方式

(3)猜测三

只保存成员变量，成员函数存放在公共的代码段
存储方式
存储方式
问题：对于上述三种存储方式，计算机到底是按照什么方式来存储的？

//类中既有成员变量，又有成员函数
class A1 
{
 public:
   void f1()
   {
   }
 private:
   int _a;
}
//类中仅有成员函数
class A2 
{
 public:
   void f2() 
   {
   }
 };
 //类中什么都没有
 class A3
 {
 };

上述代码的检测方法：上述代码通过关键字sizeof(A1)类似的方式检测不同类的大小，来判断类的存储方式是哪一种。

结论：一个类的大小实际上就是该类中成员变量之和，当然要注意内存对齐(以前C语言课程详细讲解过)。注意空类的大小，空类比较特殊，编译器给空类一个字节来唯一标识这个类的对象。

3.结构体内存对齐规则

  1. 第一个成员在结构体偏移量为0的地址处。
  2. 其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处。
    注意：对齐数等于编译器默认的一个对齐数与该成员大小的较小值。(VS的默认对齐数是8)
  3. 结构体总大小为：最大对齐数(所有变量类型最大者与默认对齐参数取最小)的整数倍。
  4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己最大对齐数的整数倍处，结构体的整体大小就是所有对齐数(含嵌套结构体的对齐数)的整数倍。

八.类成员函数的this指针

1.概念引入

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 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++编译器给每个非静态的成员函数增加一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作中，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

2.this指针的特性

  1. 只能在成员函数的内部使用
  2. 本质上是成员函数的形式参数，当对象调用形式参数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
  3. this指针是成员函数第一个隐含的指针形参，一般情况下由编译器通过ecx寄存器自动传递，不需要用户手动传递。
  4. 在成员函数中，不能给this指针赋值。

3.C语言和C++语言实现栈的对比

//C语言实现
typedef int DataType;
typedef struct Stack//结构体命名为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--;//直接将数据个数-1，少去不必要的麻烦
}
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++语言实现
typedef int DataType;
class Stack
{
  public:void Init() 
  {  _array = (DataType*)malloc(sizeof(DataType) * 3);
    if (NULL == _array) 
    {
      perror("malloc申请空间失败!!!");
      return; 
    }
    _capacity = 3;
    _size = 0; 
}
void Push(DataType data) 
{
  CheckCapacity();
  _array[_size] = data;
  _size++;
}
void Pop() 
{
  if (Empty())
  return;
  _size--; 
}
DataType Top()
{ 
  return _array[_size - 1];
}
int Empty() 
{
  return 0 == _size;
}
int Size()
{
  return _size;
}
void Destroy() 
{
  if (_array) 
  {
    free(_array);
    _array = NULL;
    _capacity = 0;
    _size = 0;
  }
}
private:
  void CheckCapacity()
 {
   if (_size == _capacity)
   {
     int newcapacity = _capacity * 2;
     DataType* temp = (DataType*)realloc(_array, newcapacity *
sizeof(DataType));
     if (temp == NULL)
     {
       perror("realloc申请空间失败!!!");
       return; 
     }
     _array = temp;
     _capacity = newcapacity; 
   } 
}
private:
  DataType* _array;
  int _capacity;
  int _size;
};
int main()
{ 
  Stacks;
  s.Init();
  s.Push(1);
  s.Push(2);
  s.Push(3);
  s.Push(4);
  printf("%d\n", s.Top());
  printf("%d\n", s.Size());
  s.Pop();
  s.Pop();
  printf("%d\n", s.Top());
  printf("%d\n", s.Size());
  s.Destroy();
  return 0;
}

上述两种语言实现的栈结构的代码，略有不同。C语言在实现时，每个函数的第一个参数都是stack *，函数中必须要对第一个参数检测，因为该参数可能为NULL。函数中都是通过stack指针参数操作栈的。调用时，必须传递stack结构体变量的地址。
结构体只能定义存放数据的结构，操作数据的方法不能放在结构体中，即数据和操作数据的方式是分离开的，而且实现上相对复杂。涉及到大量的指针操作。
C++语言中通过类可以将数据以及操作数据的方法进行完美的结合，通过访问权限可以控制那些方法在类外被调用(封装)，在使用时就像使用自己成员一样。而且每个方法不需要传递stack指针参数了，编译器编译之后，会将该参数自动还原，即C++中stack指针参数是编译器维护的，C语言需要自己进行维护。

# c++ # 开发语言
Logo
AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

cover

AI Agent 的使用进化史

avatar AI Agent技术社区
cover

AI Agent 工程师崛起：从调参侠到系统架构师，掌握这四大能力成行业香饽饽！

avatar AI Agent技术社区
cover

人在回路（HITL）：为AI Agent系上“安全带”

avatar AI Agent技术社区