C++ NULL与Nullptr如何区分使用场景以及指针的正确使用

最新推荐文章于 2024-07-25 20:22:48 发布
最新推荐文章于 2024-07-25 20:22:48 发布
阅读量857 收藏 12
点赞数 29
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014634649/article/details/138732584
版权

C++ NULL与Nullptr

背景

静态代码检查出问题了，虽然我知道应该用nullptr取代 NULL。但是原因不清楚，借着这次静态代码检查，想彻底弄清楚这个问题。

NULL USED IN INTEGER CONTEXT.


定义：
hal  *mHal;

使用：
if **(NULL != mHal)**{
    delete mHal;
}

关键知识点

指针和对象的关系

void testPointer() {
    int value = 30;
    int *ptr2 = &value; // 指向值为0的指针
    std::cout << "value的值 " << value << std::endl;
    std::cout << "value的地址 " << &value << std::endl;
    std::cout << "ptr2的值 " << ptr2 << std::endl;
    std::cout << "ptr2的地址 " << &ptr2 << std::endl;
    std::cout << "ptr2指针指向的值 " << *ptr2 << std::endl;
}

**output：**
value的值 30
value的地址 0x5ffd0c
ptr2的值 0x5ffd0c
ptr2的地址 0x5ffd00
ptr2指针指向的值 30

对于一个指针有三种操作方式

  • 取值（The Pointer Itself）
ptr2：获取指针的值，实际代表的意义就是指针指向的对象的地址。
  • 取地址（Address-of Operator）
&ptr2：获取指针自身的地址。
  • 解引用（Dereferencing Operator）
*ptr2：用于访问指针指向的内存地址中存储的数据。

关系总结

在这里插入图片描述

  • 指针的值是特殊的，因为它是另一个对象的地址。
  • 指针本身的地址是存储在栈上的，只有当包含指针的函数返回后，指针本身的存储空间才可能被回收（从栈上清除）。
  • 对象的地址有可能在栈上，也有可能在堆上，取决于创建对象的方式。

由指针和对象的关系这三张图，可以引申出很多话题。

  • 当指针指向地址0 —》空指针
  • 当指针指向地址没有对象时 —》悬空指针
  • 当指针没了，但是对象还在时-》内存泄漏

理解delete

int* ptr = new int(42); // 动态分配内存
delete ptr;             // 释放内存
std::cout << *ptr;      // 悬空指针解引用，未定义行为

上面这个delete ptr是释放ptr指向对象的内存，也就是通过new int(42)分配的内存，指针本身的内存还是在的，而且指针还是指向这个地址（指针的值还在）。但是当解引用的时候，发现这个地址没有对象，那么就会成为一个悬空指针。

MMU基本工作

代码中的通过指针访问数据，背后都是MMU（内存管理单元）在工作，它接收进程的虚拟地址，转到物理地址中，获取数据。

内存管理单元（MMU）和操作系统通过维护一个页表来管理内存地址到物理内存的映射。当程序尝试访问一个地址时，MMU会查看这个地址是否在页表中有一个有效的映射。如果没有（比如地址**0**通常不映射），操作系统会发现这是一个非法访问，并可能产生一个错误，如段错误（Segmentation Fault）。

因此，空指针通常表示为地址**0的指针，它总是被认为是无效的，因为标准规定了这个地址不应该被访问。但是，任何没有被映射到有效物理内存的地址都可以导致访问错误，不仅仅是地址0**。在现代操作系统中，尝试访问任何不属于程序分配的内存段的地址都会导致错误，不管这个地址的具体数值是多少。

这就是空指针报错的原理。

空指针

空指针是指针类型的特殊值，它不指向任何有效的内存地址。在大多数编程环境中，空指针的内部表示是数值0，但这并不意味着它指向内存地址0。实际上，地址0通常是由操作系统保留的，不允许普通程序访问，以便用来表示空指针这种特殊情况。

当我们说一个指针是空指针时，我们的意思是它没有指向任何对象或者说它的值是一个非法的内存地址（通常是数值0）。在C和C++中，这样的指针通常被初始化为**NULL（在C++11中推荐使用nullptr**）。
在这里插入图片描述
在这里插入图片描述
当程序尝试访问空指针指向的内存时，操作系统通常会捕捉到这个非法操作。大多数现代操作系统都有内存保护机制，当进程尝试访问不属于它的内存区域时，操作系统会介入。

在许多操作系统中，地址**0（空指针通常表示的地址）是特殊保留的，不允许访问。操作系统的内存管理单元（MMU）会检查内存访问操作。如果检测到对地址0**的访问尝试，MMU会向CPU发出一个信号，通常是“段错误”（segmentation fault）或“访问违规”（access violation），这会导致操作系统中断程序执行。

悬空指针

除了直接的空指针（即值为0的指针）外，也有可能出现所谓的“悬空指针”（dangling pointer）错误，其中指针指向的内存已被释放或无效。这种情况下，指针的值不是0，但尝试解引用这样的指针也是未定义行为，同样可能导致程序崩溃。

以下是几个悬空指针的例子：

  1. 释放后的悬空指针：
int* ptr = new int(42); // 动态分配内存
delete ptr;             // 释放内存
std::cout << *ptr;      // 悬空指针解引用，未定义行为
  1. 超出作用域的悬空指针：
int* ptr = nullptr;
{
    int a = 42;
    ptr = &a;           // ptr 现在指向 a
}                       // a 的作用域结束，ptr 成为悬空指针
std::cout << *ptr;      // 悬空指针解引用，未定义行为
  1. 已经移动的对象的悬空指针：
int* ptr1 = new int(42); // 动态分配内存
int* ptr2 = ptr1;        // ptr2 现在指向同一内存
delete ptr1;             // 释放内存
ptr1 = nullptr;          // ptr1 现在是空指针
std::cout << *ptr2;      // ptr2 成为悬空指针，解引用它是未定义行为

指针本身的地址是存储在栈上的，只有当包含指针的函数返回后，指针本身的存储空间才可能被回收（从栈上清除）。指针本身的地址不会因为**delete**操作而出错，出错的是尝试访问指针所指向的已经释放的内存。

正确的做法是，在释放指向的内存后，立即将指针设置为**nullptr**，以避免悬空指针的问题：虽然仍然有可能出现空指针问题，这比悬空指针更容易诊断和调试，因为许多系统在尝试解引用空指针时会立即崩溃。

int* ptr = new int(42); // 动态分配内存
delete ptr;             // 释放内存
ptr = nullptr;          // 将ptr设置为nullptr

内存泄漏

如果指针指向的内存没有被释放，而指针本身的作用域结束了（例如，指针是局部变量，且没有其他引用指向同一块内存），那么我们就无法再访问或释放那块内存。这种情况被称为内存泄漏。例如

void test() {
    int*  ptr = new int(30);
}

int main() {
    test();
}

main调用test方法，test中new了一个int对象，赋值30，同时一个栈上的指针ptr指向这个对象，当test方法结束时，ptr被回收（栈上内存是系统维护的），但是int对象没有被delete，因此这块内存永远都没法被回收，就造成了内存泄漏。

容易出现的场景

  • 在函数或类中分配内存，但忘记在函数或类析构函数中释放内存。
  • 使用std::list 等容器类，但忘记在容器销毁前释放容器中元素的内存。
  • 使用第三方库或 API 时，忘记释放库或 API 分配的内存。

解决方案

避免内存泄漏的技巧:

  • 在分配内存后，养成立即释放内存的习惯。
  • 使用智能指针，例如 std::unique_ptr 和 std::shared_ptr，自动管理内存。
  • 使用内存调试工具

野指针

野指针（Wild Pointer）是指那些未被初始化的指针或已释放内存后未置为 nullptr 的指针。这些指针指向的内存地址是不确定的，可能指向任意位置，其行为是未定义的。访问或操作野指针指向的内存会导致不可预知的后果，比如数据损坏、程序崩溃或其他安全漏洞。

野指针可能由以下几种情况造成：

  1. 未初始化的指针：在 C 或 C++ 中声明指针而未给它赋值会导致野指针。例如：

    int *ptr; // 声明了一个指针但没有初始化
*ptr = 42; // 未定义行为，因为 ptr 指向一个随机的内存地址

  2. 内存释放后的指针：当使用 delete 或 free 释放了一块内存后，如果没有将指针置为 nullptr，这个指针就变成了野指针。例如：

    int *ptr = new int(42);
delete ptr; // ptr 现在是野指针
*ptr = 0; // 未定义行为，因为 ptr 指向的内存已经被释放

  3. 超出作用域的局部变量地址：函数内部的局部变量在函数返回后其作用域结束，它们的地址不再有效。如果有指针存储了这些局部变量的地址，那么这些指针也将变成野指针。例如：

    int *ptr;
{
    int value = 42;
    ptr = &value;
} // value 的作用域结束，ptr 现在是野指针

为了避免野指针，应该总是初始化指针，释放内存后立即将指针置为 nullptr，并确保不保留超出作用域变量的地址。这些好的编程习惯有助于减少程序中潜在的错误和风险。在现代 C++ 编程中，建议使用智能指针（如 std::unique_ptr 和 std::shared_ptr）管理内存，因为它们会自动处理内存释放和指针无效的情况，从而避免野指针的问题。

NULL与nullptr的区别

void func(int n);
void func(char *s);

func( NULL ); // guess which function gets called?   --func(int)
func( Nullptr ); // guess which function gets called?   --func(char* s)

实际func( NULL )会引起混淆，一般情况下大家以为NULL表示空指针，所以觉得NULL是一个指针，调用的是func（char *s）这个函数。但结果却是调用的是func(int n)，因为NULL实际上是一个宏，定义为#define NULL 0。

如果使用的是Nullptr的话，func（Nullptr）就调用的是func（char* s），没有歧义。Nullptr是c++11提出的，Nullptr是std::nullptr_t类型，表示空指针。std::nullptr_t并不是指针类型，但是可以隐式转换为任何指针类型，但重要的是不会转换为任何整数类型。

指针不初始化的问题

int* ptr;
cout<<"ptr = "<<ptr<<endl;
cout<<"*ptr = "<<*ptr<<endl;

结果
ptr = 0x1f599511870
*ptr = -1722738719

可以看到指针指向的对象的值是一个无序的随机数，这不是coder想要的结果，所以指针一定要初始化，使用nullptr或者直接指向一个创建的对象。

系统如何只根据起始地址就能获取正确的内存区域

当通过指针访问一个对象时，确实，指针存储的是对象在内存中的起始地址。对象在内存中占用一段连续的地址空间，这段空间的大小由对象的类型决定。编译器在编译时根据对象的类型信息知道如何从起始地址开始，以及需要多少字节的空间来存储或访问该对象的全部数据。

如何访问对象的不同部分

  1. 基本类型：对于基本数据类型（如**int、float等），编译器知道其大小（例如，int通常是4字节）。当你通过一个指向int类型的指针访问int**对象时，编译器生成的代码会读取或写入从指针指向的地址开始的4字节。
  2. 复合类型：对于结构体或类等复合类型，编译器根据其定义知道每个成员的类型和顺序，以及每个成员相对于对象起始地址的偏移量。当你访问这些成员时，编译器会计算出正确的地址（起始地址+成员偏移量），并根据成员的类型决定需要读取或写入的字节数。

示例

考虑以下结构体：

struct MyStruct {
    int a;
    double b;
};

如果你有一个指向**MyStruct类型的指针ptr，并且你想访问成员a和b**：

MyStruct* ptr = new MyStruct{10, 20.0};
int valueA = ptr->a;  // 访问 a 成员
double valueB = ptr->b;  // 访问 b 成员

在这个例子中：

  • ptr 存储了**MyStruct**对象的起始地址。
  • 当访问**ptr->a时，编译器知道a是结构体的第一个成员，因此直接在ptr指向的地址读取相应大小（int**类型的大小）的数据。
  • 当访问**ptr->b时，编译器知道b紧随a之后，计算b的偏移量（a的大小），然后在ptr指向的地址加上这个偏移量处读取相应大小（double**类型的大小）的数据。

结论

通过类型信息和编译器的知识，即使指针只存储对象的起始地址，编译器也能正确地访问对象的整个内容或其特定部分。编译器在编译阶段就已经计算好了如何根据起始地址和类型信息访问对象的每个部分，包括对象的每个成员变量。这一切都是在编译时静态决定的，无需在运行时动态计算。

指针的内存大小

uint8_t* ptr3 = nullptr;
int* ptr = nullptr;
double* ptr2 = nullptr;
cout<<"ptr size = "<<sizeof(ptr)<<endl;
cout<<"ptr2 size = "<<sizeof(ptr2)<<endl;
cout<<"ptr3 size = "<<sizeof(ptr3)<<endl;
cout<<"int size = " <<sizeof(int)<<endl;
cout<<"double size = " << sizeof(double)<<endl;
cout<<"uint8_t size = "<<sizeof(uint8_t)<<endl;

output：
ptr size = 8    
ptr2 size = 8   
ptr3 size = 8   
int size = 4    
double size = 8 
uint8_t size = 1

可见，指针的内存大小与指针的类型无关，指针的内存大小只与计算机的位数有关，如果是64位系统，那么指针的大小就是64位（8个字节）。如果是32位系统，那么指针的大小就是32位（4个字节）。

如果指针类型与访问对象的类型不一致时，会发生什么问题？

当一个指针指向的对象类型与指针的类型不匹配时，这通常是类型不安全的，可能导致未定义行为。在C++中，类型不匹配的指针可能会导致几种问题：

  1. 类型别名问题：编译器可能无法正确理解内存中的数据应该如何被解释和处理。
  2. 对象对齐问题：如果对象类型要求特定的内存对齐，而指针类型不符合这些要求，可能会导致硬件异常。
  3. 对象大小问题：如果通过类型不匹配的指针读取对象，可能会读取错误的内存大小，导致程序错误或崩溃。
  4. 虚函数表问题：如果对象是类的实例并且有虚函数，通过不匹配的指针调用虚函数可能导致错误的虚函数表查找，结果是调用错误的函数。

在C++中，当您通过指针访问对象时，这是一个内存操作。编译器假设您提供的指针类型是正确的，并且根据该类型的大小和布局来读取内存。如果指针类型与实际对象类型不匹配，编译器生成的代码可能无法正确地解释内存中的数据。

例如：

cpp程序文件Copy code复制代码
struct A {
    int x;
};

struct B {
    double y;
};

A a;
B* bPtr = reinterpret_cast<B*>(&a); // 不安全的类型转换

在这个例子中，bPtr 试图将 A 类型的对象当作 B 类型来访问，这可能会导致读取错误的内存块大小，因为 B 的 y 成员可能比 A 的 x 成员有不同的大小和对齐要求。

C++不提供运行时的类型检查来匹配指针和对象类型；它依赖于程序员正确使用类型。这是为了性能考虑，因为运行时类型检查会增加额外的开销。当不安全的转换（如 reinterpret_cast）被使用时，程序员必须确保转换是有效的。

为什么需要用if (ptr == NULL) 替换成if (ptr ==nullptr)

1. 类型安全

  • NULL 在 C++ 中通常被定义为 0（整数零），而 nullptr 是 C++11 引入的新关键字，专门用来表示空指针。nullptr 的类型是 std::nullptr_t，可以隐式转换为任何指针类型，但不能转换为整数类型，这避免了与整数零的潜在混淆。
  • 使用 nullptr 可以提高代码的类型安全性。例如，如果有一个重载的函数，一个接受整型参数，另一个接受指针类型参数，使用 nullptr 可以明确调用接受指针参数的版本，而使用 NULL（或者直接使用 0）可能会导致调用错误的版本。

2. 更清晰的意图

  • 使用 nullptr 明确表示指针为空，这使代码的意图更加清晰。对于阅读代码的人来说，nullptr 直接表明你在处理指针，而 NULL 则不那么明显，尤其是在不同上下文中，NULL 也可能被解释为整数零。

3. 更好的兼容性

  • 在 C++11 和之后的版本中，nullptr 是标准的空指针字面量，与新的语言特性和库功能更加兼容。在一些模板编程或者泛型编程的场景中，nullptr 的引入解决了使用 NULL 可能遇到的一些问题。

4. 避免潜在的错误

  • 在某些情况下，使用 NULL 可能导致意外的类型转换或者重载解析问题。尽管在大多数情况下，编译器可以正确处理 if (ptr == NULL)，但是使用 nullptr 可以减少潜在的错误风险。

总的来说，nullptr 在 C++ 中的引入是为了提供一种更安全、更清晰、更一致的方式来表示空指针。因此，在 C++11 及其之后的代码中，推荐使用 nullptr 而不是 NULL

初始化为null/nullptr的指针值是多少？

int testGetNullptr() { 
  int* p = nullptr;

  // 检查指针是否为空
  if (p == nullptr) {
    std::cout << "指针 p 为空" << std::endl;
  } else {
    std::cout << "指针 p 指向 " << *p << std::endl;
  }
  std::cout << "指针 p 的地址" << &p <<std::endl;
  std::cout << "指针 p 的值" << p <<std::endl;
  return 0;
}

结果：
指针 p 为空
指针 p 的地址0x5ffd08
指针 p 的值0

指针是存在地址的，地址的值是0.

指针初始化指定null 和指针初始化指定一个int 类型值为0的对象，系统怎么区别？

int *ptr1 = nullptr; // 空指针，不指向任何内存地址

int value = 0;
int *ptr2 = &value; // 指向值为0的指针
if(ptr == NULL) //由于ptr的值是value的地址，所以ptr肯定不等于NULL（宏定义0）

static_cast/dynamic_cast/const_cast/reinterpret_cast类型抓换比较

  1. static_cast：
    • 用于非多态类型的转换。
    • 可以用来转换相关类型（例如，将**float转换为int**）。
    • 可以用于向上转换（派生类指针转换为基类指针）。
    • 无法用于向下转换（基类指针转换为派生类指针），除非没有虚函数，这时不需要运行时类型检查。
  2. dynamic_cast：
    • 主要用于处理多态类型。
    • 可以在类层次结构中安全地向上和向下转换，用于基类和派生类之间的转换。
    • 在向下转换时，它会检查转换是否有效，如果不有效，则返回**nullptr**（对于指针）或抛出异常（对于引用）。
    • 它需要运行时类型信息（RTTI），因此有一定的性能开销。
  3. const_cast：
    • 用于移除或添加**const（或volatile**）属性。
    • 常用于需要向不能修改的对象传递参数的函数中，特别是当知道实际上不会修改该对象时。
    • 不能改变表达式的类型，仅用于改变对象的常量性。
  4. reinterpret_cast：
    • 是最不安全的转换类型。
    • 可以将任何指针转换为任何其他指针类型（例如，将**int*转换为char*或void***转换为任何类型的指针）。
    • 可以转换为足够大的整数类型。
    • 不执行任何类型检查，转换后的有效性完全取决于程序员。
    • 通常用于低级操作，如转换指针到足够大的整型，或者在不同指针类型之间转换时，当你确切知道它是安全的。

在实际使用中，应当尽可能使用**static_cast、dynamic_cast和const_cast，因为它们提供了类型安全性。reinterpret_cast应该非常小心使用，因为它可能会导致未定义行为。在不确定的情况下，避免使用reinterpret_cast**，或者仅在你完全理解可能的后果，并且确信它不会引起程序错误时使用。

curry30
关注
  • 29
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ NULL和nullptr区别
lucas1997的博客
11-16 248
在编写C程序的时候只看到过NULL，而在C++的编程中，我们可以看到NULL和nullptr两种关键字，其实nullptr是C++11版本中新加入的，它的出现是为了解决NULL表示空指针在C++中具有二义性的问题，为了弄明白这个问题，我查找了一些资料，总结如下。 一、C程序中的NULL 在C语言中，NULL通常被定义为：#define NULL ((void *)0) 所以说NULL实际上是一个空指针，如果在C语言中写入以下代码，编译是没有问题的，因为在C语言中把空指针赋给int和char指针的时候，
C++指针介绍及使用说明
10-09
空指针（`NULL`或`nullptr`）是一个没有指向任何有效地址的指针，直接使用空指针会导致未定义的行为，应当避免。在访问指针之前，务必确保它指向的内存是已分配并且有效的，否则可能会造成程序崩溃。例如，如果一个...
【C/C++】关键字nullptr详解 | NULL与nullptr的区别
努力让自己的能力配得上梦想.
06-12 1万+
在C++中，引入了一个新的关键字——``nullptr``，用来代替旧版本的`NULL`，在函数重载中，宏替换NULL和整型0造成歧义 需要nullptr代表空指针而非整型0 关键字nullptr提高了程序的类型安全性和可读性，与NULL宏定义相比，具有更强的可靠性和扩展性。 三、NULL和nullptr的区别✧ NULL和nullptr都能当作空指针进行使用，他们之间本质的区别是什么呢？ NULL是一个宏，替换的是0 ，而nullptr是关键字，代表空指
【C++】nullptr
Hi, Boy
05-04 263
【代码】【C++】nullptr。
C++中NULL和nullptr的区别（建议使用 nullptr）
u011326153的博客
01-25 605
在C++中，NULL 和 nullptr 都用于表示空指针，但它们之间有一些重要的区别。
C++中NULL和nullptr
weixin_41653613的博客
03-10 1312
C++中NULL和nullptr
【C++】NULL和nullptr的关联与差别
热门推荐
Yngz_Miao的博客
03-29 1万+
在写代码的过程中，有时候需要将指针赋值为空指针，以防止野指针。在C中，都是使用NULL来实现的；在C++中，除了NULL之外，还提供了nullptr来进行定义。那么两者之间有什么区别呢，分别适用于什么类型的场景呢？ 本文实例源码github地址：https://github.com/yngzMiao/yngzmiao-blogs/tree/master/2020Q1/20200329。 NULL...
【C++】空指针弃NULL用nullptr
Qiuhan_909的博客
03-19 487
空指针（null pointer）不指向任何对象，在试图使用一个指针之前代码可以首先检查它是否为空。在新标准下，现在的C++程序最好使用nullptr，同时尽量避免使用NULL。
c++中null和nullptr的区别
m0_63096674的博客
03-23 697
nullptr是C++11标准中新增的关键字，它是一个空指针常量，可以用来初始化指针变量或与指针变量进行比较。与null不同的是，nullptr的类型是std::nullptr_t，而不是整数类型。null是C++早期版本中用来表示空指针的关键字，它实际上是一个整数常量。在C++11标准中，null被定义为一个宏，它的值也是。因此，使用null表示空指针时，实际上是将一个整数常量赋值给指针变量。C++中的null和nullptr都是表示空指针的关键字，但它们的含义和用法有所不同。
c++ 指针与引用的区别介绍及使用说明
09-05
以下是关于指针与引用的区别以及使用场景的详细介绍： 1. **初始化**： - 引用在声明时必须初始化，并且一旦初始化后就始终绑定到同一对象，不能改变其引用的对象。例如： ```cpp string s1("Nancy"); string ...
03 指针定义以及概念.rar_C++_指针
09-21
空指针常被表示为`nullptr`（在C++11及以后版本）或`NULL`（在旧版本），它不指向任何内存块，是一种安全的状态。而指向有效内存的指针则指向了一个已分配的变量或内存区域。 在C++中，有几种特殊的指针类型，如...
2.const对象-NULL和nullptr-C++中创建对象数组.docx
11-21
在这篇文章中，我们将讨论C++编程语言中的几个重要概念，包括const对象、NULL和nullptr、new和delete操作符、malloc和free函数等。 1.(const对象) 在C++中，const对象是一个不可改变的对象，它的值不能被修改。...
C++指针 详细介绍及总结
09-01
C++中的指针是编程语言的...另外，指针在释放内存后应设为`NULL`或`nullptr`，以避免后续使用。 总之，C++指针是一种强大的工具，但需要谨慎使用。理解和熟练掌握指针的各个方面对于编写高效且可靠的C++代码至关重要。
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1200
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
【C++】：红黑树深度剖析 --- 手撕红黑树！
最新发布
2301_77900444的博客
07-25 1702
就是太过追求绝对平衡，比如在插入时要维护其绝对平衡，旋转次数太多，在删除时甚至有可能要一直旋转到根位置，使之性能低下。本篇文章介绍的红黑树也是一种平衡树，是通过改变节点颜色以及旋转操作，使之接近平衡。红黑树比AVL树的用途更加广泛，在一些方面效率甚至要优于AVL树，并且 map/set 的底层封装用的也是红黑树。红黑树的节点结构与AVL树的大致相同，只是AVL树中有节点的颜色，没有平衡因子。//枚举颜色RED,BLACK,_kv(kv){}
C++ primer plus 第16章string 类和标准模板库, 关联容器
zhyjhacker的博客
07-25 665
C++ primer plus 第16章string 类和标准模板库, 关联容器。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 275
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
c++NULL与nullptr有什么区别
05-31
在C++11中，引入了nullptr关键字，用于代替C++03中的NULL宏定义。C++03中的NULL实际上是一个整数常量0，...总之，C++11中的nullptr是一个更加安全和明确的空指针常量，建议在新的代码中使用nullptr代替C++03中的NULL。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值