当前位置： 首页 > news >正文

【C++类】

news 2025/7/12 20:36:46

C++类

  • 1.类的引入
  • 2.类的定义
  • 3、访问限定符
  • 4.类的作用域
  • 5.类的实例化
  • 6.计算类对象的大小
  • 7.this指针
  • 8、构造函数
  • 9.析构函数
  • 10、拷贝构造函数

1.类的引入

 C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。比如：之前在数据结构初阶中，用C语言方式实现的栈，结构体中只能定义变量；现在以C++方式实现，会发现struct中也可以定义函数。

//stack.h
#pragma once
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
using namespace std;
typedef int TypeData;
struct Stack
{
public://void Init();Stack();void Push(TypeData x);void Pop();TypeData Top();int Empty();int Size();//void Destory();~Stack();
private:void CheakCapacity();
private:TypeData* _array;int _size;int _capacity;
};

//Stack.cpp
#include "Stack.h"//void Stack::Init()
//{
//	_array = nullptr;
//	_size = 0;
//	_capacity = 0;
//}Stack::Stack()
{_array = nullptr;_size = 0;_capacity = 0;
}Stack :: ~Stack()
{assert(_array);free(_array);_array = nullptr;_size = 0;_capacity = 0;
}
void Stack:: Push(TypeData x)
{CheakCapacity();_array[_size] = x;_size++;
}void Stack:: Pop()
{assert(_array);_size--;
}TypeData Stack:: Top()
{return _array[_size - 1];
}int Stack:: Empty()
{assert(_array);return _size == 0;
}int Stack:: Size()
{assert(_array);return _size;
}void Stack::CheakCapacity()
{if (_size == _capacity){int newcapacity = _capacity == 0 ? 2 : _capacity * 2;TypeData* tmp = (TypeData*)realloc(_array, sizeof(TypeData) * newcapacity);if (tmp == nullptr){perror("realloc fail");return;}_array = tmp;_capacity = newcapacity;}
}//void Stack :: Destory()
//{
//	assert(_array);
//	free(_array);
//	_array = nullptr;
//	_size = 0;
//	_capacity = 0;
//}

//Test.cpp
#include"Stack.h"int main()
{Stack st1;//st1.Init();st1.Push(1);st1.Push(2);st1.Push(3);st1.Push(4);while (!st1.Empty()){cout << st1.Top() << " ";st1.Pop();}//st1.Destory();return 0;
}

 上述结构体的定义，更喜欢用class来定义

2.类的定义

class className
{// 类体：由成员函数和成员变量组成};

 class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。
类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。


 类的两种定义方式：1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。
alt

 2. 类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名::
alt

 看下面代码，初始化不了。
Alt

 原因是成员变量跟成员函数形参一样。做下面改进
alt

3、访问限定符

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

 【访问限定符说明】

  1. public修饰的成员在类外可以直接被访问
  2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
  3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
  4. 如果后面没有访问限定符，作用域就到 } 即类结束。
  5. class的默认访问权限为private，struct为public(因为struct要兼容C)
    注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别
    问题：C++中struct和class的区别是什么？
    解答：C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。注意：在继承和模板参数列表位置，struct和class也有区别，后序给大家介绍。
     面向对象的三大特性：封装、继承、多态。

4.类的作用域

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

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

5.类的实例化

 用类类型创建对象的过程，称为类的实例化。
一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量。
Person类是没有空间的，只有Person类实例化出的对象才有具体的年龄。

int main()
{Person._age = 100;   // 编译失败：error C2059: 语法错误:“.”return 0;
}

6.计算类对象的大小

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

 存储形式：只保存成员变量，成员函数存放在公共的代码段
Alt
Alt

 结论：一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

7.this指针

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

 this指针特性.

  1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。
  2. 只能在“成员函数”的内部使用（来指示成员变量）
  3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
  4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递
    Alt
class A
{
public:void Print(){cout << this << endl;cout << "Print()" << endl;}
private:int _a;
};int main()
{//定义了一个A类型的指针pA* p = nullptr;//nullptr传给了Print里面的this指针，没影响//跟访问结构体一样，可以访问p->Print();//A a;//a._a = 1;//A* pp = &a;//cout << "pp->_a" << pp->_a << endl;return 0;
}

class A
{
public:void PrintA(){cout << _a << endl;}
private:int _a;
};int main()
{//A a;//A* p = &a;A* p = nullptr;//this是nullptr进入PrintA之后找不到_a;p->PrintA();return 0;
}

Alt

8、构造函数

 构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。
 构造函数特性如下：
Alt

class Date
{
public://1.无参构造函数Date(){}//2.带参构造函数Date(int year, int month, int day){_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;
};int main()
{Date d1; //定义了d1对象，并且自动调用了无参构造函数，他支持函数重载Date d2(2025, 1,1); //定义d2选项，调用带参的构造函数// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象// warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)Date d3();return 0;
}

 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦
用户显式定义编译器将不再生成。

class Date
{
public:/*// 如果用户显式定义了构造函数，编译器将不再生成Date(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类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数// 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成// 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用Date d1;return 0;
}

Alt
 上面说是系统自动生成构造函数，进行初始化成员变量，但是变量里面是随机值。

 关于编译器生成的默认成员函数，很多童鞋会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？
解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类
型，如：int/char…，自定义类型就是我们使用class/struct/union等自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数(不传参就调用的那个函数)。

class Time
{
public:Time(){cout << "Timee()" << endl;_hour = 0;_minute = 0;_second = 0;}
private:int _hour;int _minute;int _second;
};class Date
{
private:int _year;int _month;int _day;//自定义类型Time _t;
};int main()
{Date d;return 0;
}

Alt
Alt
 C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值。在类的声明处直接赋值即可。
Alt

 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为
是默认构造函数。
Alt

 
 

9.析构函数

Alt

typedef int DataType;
class Stack
{
public://构造函数Stack(size_t capacity = 3){_array = (DataType*)malloc(sizeof(DataType) * capacity);if (nullptr == _array){perror("malloc申请空间失败!!!");return;}_capacity = capacity;_size = 0;}void CheckCapacity(){	if (_size == _capacity){_array = (DataType*)realloc(_array,sizeof(DataType) * _capacity*2);if (nullptr == _array){perror("malloc申请空间失败!!!");return;}_capacity *= 2;}}void Push(DataType data){CheckCapacity();_array[_size] = data;_size++;}DataType Top(){return _array[_size - 1];}void Pop(){_size--;}int Empty(){return  _size == 0;}//析构函数~Stack(){if (_array){free(_array);_array = NULL;_capacity = 0;_size = 0;}}
private:DataType* _array;int _capacity;int _size;
};

Allt
  关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的默认析构函数，对自定类型成员调用它的析构函数。

class Time
{
public:~Time(){cout << "~Time()" << endl;}
private:int _hour;int _minute;int _second;
};
class Date
{
private:// 基本类型(内置类型)int _year = 1970;int _month = 1;int _day = 1;// 自定义类型Time _t;
};
int main()
{Date d;return 0;
}

Alt

// 程序运行结束后输出：~Time()
// 在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？
// 因为：main方法中创建了Date对象d，而d中包含4个成员变量，其中_year, _month, _day三个是内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；而_t是Time类对象，所以在d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。但是：main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁
// main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数
// 注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数。

 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。


Alt

10、拷贝构造函数

 拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。
 拷贝构造函数特征

  1. 拷贝构造函数是构造函数的一个重载形式。
  2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。
    Alt

 传参问题。

class Date
{
public:Date(int year = 1, int month = 1, int day = 1){_year = year;_month = month;_day = day;}Date(Date& d){cout << "Date(Date& d)" << endl;_year = d._year;_month = d._month;_day = d._day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year = 1;int _month = 1;int _day = 1;
};void fun(Date d)
{d.Print();  
}int main()
{Date d1(2025, 1, 4);fun(d1); //类对象传参先调用拷贝构造，在执行Print();return 0;
}

 看上面函数的调用，
alt

 类对象传值传参，//类对象传参先调用拷贝构造，在执行Print()
alt
 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
alt

class Time
{
public:Time(){_hour = 1;_minute = 1;_second = 1; }Time(const Time& t){_hour = t._hour;_minute = t._minute;_second = t._second;cout << "Time::Time(const Time&)" << endl;}
private:int _hour;int _minute;int _second;
};
class Date
{
private:// 基本类型(内置类型)int _year = 1970;int _month = 1;int _day = 1;// 自定义类型Time _t;
};
int main()
{Date d1;// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数Date d2 =d1;return 0;
}

Alt
alt
Alt
 类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。
 
 
 
 
 

http://www.xdnf.cn/news/1105345.html

相关文章：

  • 速盾：高防CDN和普通CDN的区别大吗？
  • 【MySQL】———— 索引
  • 数据分析师如何构建自己的底层逻辑？
  • 12. 说一下 https 的加密过程
  • c++26新功能—copyable_function
  • 慕尚花坊项目笔记
  • MoE混合专家模型：千亿参数的高效推理引擎与架构革命
  • 论容器化 | 分析Go和Rust做医疗的后端服务
  • Linux711 Mysql
  • 2025十大免费销售管理软件推荐
  • 《每日AI-人工智能-编程日报》--7月11日
  • Kafka-日常运维命令
  • 一个中层管理者应该看什么书籍？
  • TCP协议详解——初识
  • SQL开窗函数
  • Guava LoadingCache
  • LLM场景下的强化学习【GRPO】
  • 在线重装 Proxmox VE
  • DeepSeek模型分析及其在AI辅助蛋白质工程中的应用-文献精读148
  • C语言文件读写操作详解：fgetc与feof函数的应用
  • RestTemplate动态修改请求的url
  • C++前缀和与差分的深度探索
  • 信号量机制
  • Python-正则表达式-信息提取-滑动窗口-数据分发-文件加载及分析器-浏览器分析-学习笔记
  • Windows GNU Radio避坑
  • 【牛客刷题】dd爱科学1.0
  • 计算机网络第三章(6)——数据链路层《网桥交换机》
  • PHT-CAD 笔记
  • 深入MyBatis：CRUD操作与高级查询实战
  • Visual Studio Code 的 settings.json 配置指南