C++类和对象(上)

已于 2024-04-10 17:24:54 修改
阅读量1.1k 收藏 30
点赞数 39
分类专栏： C++学习 文章标签： c++ 开发语言
于 2024-04-03 21:28:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74319491/article/details/137243494
版权

C++类和对象

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

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

在这里插入图片描述

C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
在这里插入图片描述

2.类的引入

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

//C++兼容C结构体用法
typedef struct ListNode
{
	int val;
	struct ListNode* next;
}LTN;

//C++把结构体升级成了类
//1个类 实例化多个对象
//1.类里面可以定义函数
//2.struct名称就可以代表类型
struct ListNode
{
	int val;
	ListNode* next;//ListNode就是类型,不用加struct
};

在类中定义函数

#include <iostream>
using namespace std;

//类里面会全局搜索，不需要变量定义在函数前面
struct Stack
{
	//成员函数
	void Init(int n = 4)
	{
		a = (int*)malloc(sizeof(int) * n);
		if (a == nullptr)
		{
			perror("malloc fail");
			return;
		}

		capacity = n;
		size = 0;
	}

	void Push(int x)
	{
		//...
		//检查扩容
		a[size++] = x;
	}

	//成员变量
	int* a;
	int size;
	int capacity;
};

int main()
{
	Stack st;
	st.Init();
	st.Push(1);
	st.Push(2);
	st.Push(3);
	
	return 0;
}

上面结构体的定义，在C++中更喜欢用class来代替

3.类的定义

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

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。

类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。

类的两种定义方式：

  1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。
    在这里插入图片描述

  2. 类声明放在.h文件中，成员函数定义放在.cp 加类名::
    在这里插入图片描述

//Stack.h
#include <stdlib.h>

struct Stack
{
	void Init(int n = 4);

	void Push(int x);

	int* a;
	int size;
	int capacity;
};

//Stack.cpp
#include "Stakc.h"

void Stack::Init(int n)
{
	a = (int*)malloc(sizeof(int) * n);
	if (a == nullptr)
	{
		perror("malloc fail");
		return;
	}

	capacity = n;
	size = 0;
}

void Stack::Push(int x)
{
	//...
	//检查扩容
	a[size++] = x;
}

//test.cpp
#include "Stakc.h"

int main()
{
	Stack st;
	st.Init();
	st.Push(1);
	st.Push(2);
	st.Push(3);
	
	return 0;
}

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

4.1 访问限定符

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

在这里插入图片描述
【访问限定符说明】

  1. public修饰的成员在类外可以直接被访问
  2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
  3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
  4. 如果后面没有访问限定符，作用域就到 } 即类结束。
  5. class的默认访问权限为private，struct为public(因为struct要兼容C)
class Stack
{
public://共有函数的在外面也可以访问
	//成员函数
	void Init(int n = 4);
	void Push(int x);

private://私有属性只能在类里面访问
	//成员变量
	int* a;
	int size;
	int capacity;
};

注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

【面试题】：C++中struct和class的区别是什么？

解答：C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。

#include <iostream>
using namespace std;

class Date
{
public:
	void Init(int year, int month, int day)
	{
		year = year;
		month = month;
		day = day;
	}

private:
	int year;
	int month;
	int day;
};

int main()
{
	Date d1;
	d1.Init(2024, 4, 1);
	
 	return 0;
}

这样写并没有把对象d1的成员变量初始化，因为局部优先，所以在Init里面只是把值赋值给形参，并不会改变成员变量，所以，为了方便区分通常在成员变量名字前面加一个’_'字符。

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;
};

在C++中，当您在类的成员函数内部使用一个变量时，编译器会按照以下顺序来查找这个变量的声明：

  1. 当前作用域：编译器首先检查当前作用域（通常是函数体或类作用域）中是否有匹配的名称。如果有，编译器将停止搜索并使用当前作用域内的声明。
  2. 类的成员：如果在当前作用域没有找到匹配的名称，编译器将继续在类作用域内查找。这包括类的成员变量和成员函数。同样，访问权限受到访问控制限制（如public、private和protected）的影响。
  3. 基类的成员(暂时不用管)：如果当前类派生自一个或多个基类，并且名称在当前类作用域内未找到，编译器将在基类的作用域中继续查找。查找顺序遵循继承层次结构，从直接基类开始，然后逐级向上查找。需要注意的是，基类中的名称可能会被子类隐藏，因此在子类中，需要使用作用域解析运算符（::）来明确指定要访问基类的成员。
  4. 全局作用域：如果在类作用域及其基类作用域中都未找到匹配的名称，编译器将在全局作用域中查找。如果全局作用域中存在匹配的名称，编译器将使用全局作用域中的声明。

4.2 封装

【面试题】面向对象的三大特性：封装、继承、多态。

在类和对象阶段，主要是研究类的封装特性，那什么是封装呢？

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
封装本质上是一种管理，让用户更方便使用类。比如：对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。

在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. 类的实例化

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

  1. 类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；比如：入学时填写的学生信息表，表格就可以看成是一个类，来描述具体学生信息。
  2. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量
int main()
{
	Person._age = 100;   // 编译失败：error C2059: 语法错误:“.”
	return 0;
}

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

  1. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

在这里插入图片描述
在这里插入图片描述

//类 -- 别墅设计图
class Date
{
public:
	void init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year; //声明
	int _month;
	int _day;
};

int main()
{
	//类对象实例化 -- 开空间
	//实例化 -- 用设计图建造一栋栋的别墅
	Date d1;
	Date d2;
	
	return 0;
}

7.类对象模型

7.1 如何计算类对象的大小

int main()
{
	//类对象实例化 -- 开空间
	//实例化 -- 用设计图建造一栋栋的别墅
	Date d1;
	Date d2;

	cout << sizeof(d1) << endl;
	
	return 0;
}

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

7.2 类对象的存储方式猜测

  • 对象中包含类的各个成员

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

  • 代码只保存一份，在对象中保存存放代码的地址
    在这里插入图片描述
  • 只保存成员变量，成员函数存放在公共的代码段

在这里插入图片描述在这里插入图片描述

问题：对于上述三种存储方式，那计算机到底是按照那种方式来存储的？

运行结果如图：
在这里插入图片描述
结论：一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐

为什么成员变量在函数中，成员函数不在对象中？

实际上把函数的地址放到对象里面也是可以的，但是没必要，在类里面成员变量肯定是独立的，但是成员函数是公共的，因为多个对象可以使用同一个函数，所以没有必要放到对象里面，我们可以找一个公共的区域（代码段）把函数放到里面，那对象要调用这个函数的时候，就到公共区域去找而不是到这个对象里面去找。

总结：

  1. 每个成员的变量是不一样的，需要独立存储
  2. 每个对象成员函数是一样的，放到共享公共区域（代码段）
// 类中既有成员变量，又有成员函数
class A1 {
public:
	void f1() {}
private:
	int _a;
};

// 类中仅有成员函数
class A2 {
public:
	void f2() {}
};

// 类中什么都没有---空类
class A3
{};

int main()
{
	cout << sizeof(A1) << endl;
	//大小是1，这1byte不存储有效数据
	//占位，标识对象被实例化出来了
	cout << sizeof(A2) << endl;
	cout << sizeof(A3) << endl;
	
	return 0;
}

运行结果如图：
在这里插入图片描述
因为对象的实例化就是开空间，假如空类的大小是0，那么对象在实例化的时候就不会开辟空间，也取不了地址，就不能实例化，所以，它们也是有大小的，大小是一，这一个字节不是用来存储数据的，这个一个字节是用来占位，标识对象的存在的。

注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

7.3 结构体内存对齐规则

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

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 main()
{
	Date d1, d2;
	d1.Init(2024, 4, 2);
	d2.Init(2024, 4, 3);
	d1.Print();
	d2.Print();
	return 0;
}

运行结果如图：
在这里插入图片描述
对于上述类，有这样的一个问题：

Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？

C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

类似于下面的过程

typedef struct Date
{
	int _year;
	int _month;
	int _day;
}Date;

void Init(Date* this,int year, int month, int day)
{
	this->_year = year;
	this->_month = month;
	this->_day = day;
}

void Print(Date* this)
{
	cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
}

int main()
{
	Date d1, d2;
	Init(&d1,2024, 4, 2);
	Init(&d2,2024, 4, 3);
	Print(&d1);
	Print(&d2);
	
	return 0;
}

8.2 this指针的特性

  1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。

  2. 只能在“成员函数”的内部使用

  3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。

  4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递
    在这里插入图片描述

  5. 【面试题】this指针存在哪里？

栈，因为它是隐含参数 / vs下面是放到ecx寄存器里面

参数，局部变量是程序在运行期间调用函数要创建栈帧，参数，局部变量都会在这些栈帧里面存起来，函数调用结束了，这个空间就销毁了，成员函数存在代码段是指成员函数被编译出来的这些指令存放到代码段中，函数的地址就是第一句指令的地址，call的时候会到代码段中找

如图所示：
在这里插入图片描述
可以看到这里依次把2，4，2024压到栈里面，然后把d1的地址放到寄存器当中，后面再取this指针就去寄存器中去取

  1. this指针可以为空吗？
class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

	void func()
	{
		cout << "func()" << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date* ptr = nullptr;
	ptr->func();//正常运行

	return 0;
}

运行结果如图：
在这里插入图片描述

int main()
{
	Date d1, d2;

	Date* ptr = nullptr;
	ptr->Init(2024, 4, 2);//运行崩溃

	return 0;
}

函数不在对象里面在公共代码段里面，所以调用成员函数的时候，会到公共代码段区寻找，并不会有解引用的行为，所以不会报错，这里的ptr指针的意义是传递给this，有没有解引用的的行为取决于你要访问的东西在不在对象里面，而不是取决于用没有这个符号，因为编译器的实际编译是解析语法之后它他转换成为指令，可以看到下面图片中只是把ptr的指针传递给this指针并没有对这个对象进行解引用的行为。

既然成员函数在公共代码区域，那我们能不能直接调用成员函数？

  1. 受到类域的限制，一般情况下函数不加说明都会到全局去找，但是这里成员函数是在类域里面的，在全局找不到，所以(*ptr).func()或者ptr->func()说明这是这个类的成员函数，编译的时候要到这个类里面找这个函数的声明或定义。
  2. 我们要调用成员函数得传递this指针，所以通过(*ptr).func()或者ptr->func()的方式会把对象的地址传递过去，这个行为是由编译器来完成的。

如图所示：
在这里插入图片描述

8.3. C语言和C++实现Stack的对比

  1. C语言实现

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

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结构体变量的地址

结构体中只能定义存放数据的结构，操作数据的方法不能放在结构体中，即数据和操作数据的方式是分离开的，而且实现上相当复杂一点，涉及到大量指针操作，稍不注意可能就会出错。

  1. C++实现
#include <iostream>

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()
{
	Stack s;
	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*的参数了，编译器编译之后该参数会自动还原，即C++中 Stack * 参数是编译器维护的，C语言中需用用户自己维护

星光终将不负赶路人
关注
  • 39
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 26
    评论
专栏目录
C++ 类和对象（上）
yulong__li的博客
11-16 184
目录 类 类的引入 类的定义 类的访问限定符及封装 访问限定符 封装 类的作用域 类的实例化 类对象大小计算 存储方式猜测 类对象大小计算规则 结构体内存对齐 this指针 引出 this指针特性 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。...
【C++】类和对象(上)
carl_2018的博客
07-16 122
类与对象的初步认知 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 C++ 是面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 C语言中，结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。 类的定义 class className { //类体：由成员函数和成员变量组成 }; // 分号不能丢 class...
C++的类和对象
Cosmicsea的博客
05-21 5289
C++面向对象的三大特性：封装、继承、多态 C++认为万事万物皆可为对象，对象有其属性和行为 具有相同性质的对象，可以抽象为类 封装 类在设计时，可以把属性和行为放在不同的权限下，加以控制 public：公共权限，类内可访问、类外可访问， protected：保护权限，类内可访问、类外不可访问，儿子可以访问父亲的保护内容 private：私有权限，类内可访问、类外不可访问，儿子不可以访问父亲的私有内容 struct和class的区别在于 struct的默认权限是public cla
C++类和对象
wh22141334的博客
07-18 4015
c++中的类和对象
C++类和对象详解
weixin_43730061的博客
03-25 6998
类与对象上篇： 主要内容： 1.类和对象的区别。 2.类的定义。 3.类的访问限定符和封装 4.类的作用域 5.类的实例化（用类类型创建对象） 6.计算类对象的大小 7.this指针 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 1.类和对象的区别： 类是抽象的，不占用内...
C++类和对象，思维导图
04-24
C++类和对象，会跟着文章更新而更新
C++类和对象练习 实现日期类
07-29
为了更好的理解`C++`类和对象的知识,我们可以动手实现一下`C++`的一个简单的日期类,完成相应的函数,更好的帮助我们理解类和对象. 从日期类的构造函数,拷贝构造,获取当月天数,日期与天数的运算,日期类相关的比较...
c++类和对象
01-05
c++ 类和对象讲解
【C++】类和对象
iluo12的博客
04-24 2211
C++类和对象
C++类和对象的思维导图
08-02
内容比较多，都是有关C++中有关类和对象的语法。大家可以根据自己的情况去食用
c++命令模式
qq_71286244的博客
08-30 4226
c++命令模式详细介绍
c语言赋值截断
hutaotaotao的博客
09-02 463
c语言赋值过程与截断行为
【C++】智能指针——auto_ptr，unique_ptr，shared_ptr
2301_79796701的博客
09-01 1199
1.智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时 ++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错 乱了。旧的智能指针的会转移给新的智能指针，而旧的智能指针的会被置空。解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了，weak_ptr不会增加引用计数，代码示意。该问题是有类似于链表节点的结构引起的，当外部的智能指针都释放了，就拿不内部的智能指针，那么节点就不会释放。使用方法参考官方文档。
C++友类匿名对象，运算符重载
最新发布
m0_75109289的博客
09-02 117
【代码】C++友类匿名对象，运算符重载。
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 3780
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
C++的内存模型
qhu1600417010的博客
08-28 1168
C++ 的内存模型包含了程序运行时如何分配、访问、管理内存的规则，涵盖了多线程环境下的数据一致性、内存对齐、以及虚拟内存管理等内容。掌握这些概念对于编写高效、安全的 C++ 程序至关重要。
怎么解决 hash 碰撞，用 C++ 实现 hashMap？
zhanghaiou07657的博客
08-29 2619
如果要自己实现一个简单的哈希映射，可以定义一个结构体来表示哈希表中的节点，包含键值对和指向下一个节点的指针（如果采用链地址法）。在插入操作时，计算键的哈希值，若该位置已被占用且键不相同，则根据选择的解决碰撞的方法（如链地址法）将新元素插入到链表中。在查找操作时，同样计算键的哈希值，然后遍历对应的链表（如果是链地址法）来查找目标键值对。“哈希碰撞是在哈希函数计算过程中可能出现的不同输入产生相同哈希值的情况。链地址法是将哈希值相同的元素存储在一个链表中，当进行查找等操作时，遍历对应的链表来找到目标元素。
C++ | Leetcode C++题解之第390题消除游戏
Ddddddd_158的博客
09-02 124
C++ | Leetcode C++题解之第390题消除游戏
Ascend C算子开发（入门）—— 算子开发初体验
Byyyi耀的博客
08-29 2587
Ascend C算子开发（入门）—— 算子开发初体验
评论 26
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值