C++ 整理

Posted 懒懒初阳

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C++ 整理相关的知识,希望对你有一定的参考价值。

C++问题分析

C++的数据类型

C++是一种静态类型语言,它支持以下基本数据类型:

  1. 整型 (int):表示整数,可分为有符号整型(int)和无符号整型(unsigned int),不同类型占用的存储空间大小不同。
  2. 字符型 (char):表示一个字符,占用一个字节的存储空间。
  3. 布尔型 (bool):表示真或假,占用一个字节的存储空间。
  4. 浮点型 (float, double):表示实数,可分为单精度浮点数(float)和双精度浮点数(double),占用的存储空间大小不同。
  5. 空类型 (void):表示没有值,通常用于函数返回值类型或指针类型。

除了基本数据类型,C++还支持以下扩展数据类型:

  1. 枚举类型 (enum):表示一组具有名字的整数值,通常用于程序中需要使用固定值的情况。
  2. 数组类型 (array):表示一组具有相同数据类型的变量集合,可以使用下标操作访问其中的元素。
  3. 结构体类型 (struct):表示一组不同数据类型的变量集合,可以使用成员访问操作符访问其中的元素。
  4. 联合类型 (union):表示一组不同数据类型的变量集合,但是只能同时存储其中的一个元素,占用的存储空间大小取决于最大的成员类型大小。

此外,C++还支持指针类型 (pointer),引用类型 (reference)等,这些数据类型在C++的程序设计中具有重要的作用。

c++内存结构与管理

C++是一种直接操作内存的语言,因此需要程序员具备一定的内存管理知识。下面是C++内存结构和内存管理的一些具体内容:

  1. 内存结构

C++程序的内存可以分为以下几个部分:

  • 栈内存(Stack Memory):由编译器自动分配和释放,存储局部变量、函数参数等。栈内存空间大小有限,一般几MB到几十MB不等。
  • 堆内存(Heap Memory):由程序员手动申请和释放,存储动态分配的内存空间。堆内存空间大小较大,可以申请GB级别的内存空间。
  • 静态内存(Static Memory):存储全局变量和静态变量,程序在运行期间一直存在,直到程序退出才会释放。
  • 代码内存(Code Memory):存储可执行代码,由操作系统负责加载到内存中运行。
  1. 内存管理

C++程序员需要手动管理堆内存的申请和释放,否则会造成内存泄漏或者内存溢出等问题。具体的内存管理包括以下内容:

  • 动态内存申请:使用new运算符申请内存空间,并返回指向该空间的指针。例如:int *p = new int;
  • 动态内存释放:使用delete运算符释放申请的内存空间,例如:delete p;。需要注意的是,如果使用new[]运算符申请了数组类型的内存空间,需要使用delete[]运算符释放空间,例如:delete[] arr;。
  • 内存泄漏:如果程序没有正确释放申请的内存空间,就会造成内存泄漏,即申请的内存空间无法被回收,导致程序的内存使用越来越大。为了避免内存泄漏,需要在程序中明确释放申请的内存空间。
  • 空指针异常:如果使用了指针变量,但是没有初始化或者初始化为null指针,就会造成空指针异常,即访问不存在的内存空间,导致程序崩溃。为了避免空指针异常,需要在使用指针变量之前进行初始化,并进行有效性检查。

除了以上内存管理的内容外,C++程序员还需要掌握内存分配器(Memory Allocator)的使用,如STL中的malloc和free函数,以及Boost库中的Memory Pool等高级内存管理技术,以提高程序的内存使用效率和性能。

预处理指令有哪些。使用场景

C++预处理指令是指在编译代码之前由预处理器(preprocessor)处理的特殊指令,它们以#字符开头。预处理器是C++编译器的一部分,用于对代码进行文本替换、宏定义、条件编译等操作,从而在编译时生成最终的源代码。下面是一些常用的预处理指令及其使用场景:

  1. include

用于包含头文件,将其他文件中的代码复制到当前文件中。头文件中通常包含了函数声明、宏定义和常量等代码,可以提供给当前文件使用。例如:#include 表示包含标准输入输出流库的头文件iostream。

  1. define

用于宏定义,可以用来定义常量、函数、数据类型等。例如:#define PI 3.14定义了一个名为PI的常量,其值为3.14。

  1. ifdef,#ifndef,#endif

用于条件编译,可以根据指定的条件编译一部分代码。例如:#ifdef _DEBUG #include #endif表示如果宏_DEBUG已经定义,则包含头文件cassert,否则不包含。

  1. if,#elif,#else

用于条件编译,可以根据指定的条件编译一部分代码。例如:#if (x > 0) cout << "x is positive" << endl; #elif (x < 0) cout << "x is negative" << endl; #else cout << "x is zero" << endl; #endif表示根据变量x的值输出不同的消息。

  1. pragma

用于向编译器发送特定的命令或指令,可以用来控制编译器的行为或优化代码。例如:#pragma once表示指示编译器只包含当前文件一次,避免重复包含。

预处理指令可以提高代码的可读性和灵活性,可以根据不同的平台、编译器或者操作系统等定义不同的宏,从而实现跨平台编译或者编译不同版本的代码。同时也可以使用条件编译实现不同的调试或者发布版本,提高代码的可维护性和适应性。

Typedef别名有哪些

在C++中,typedef是一种定义类型别名的方法,它可以将一个类型名定义为另一个类型的别名,从而方便程序员使用。以下是常见的typedef别名及其使用场景:

  1. typedef int INT;

这条语句将int类型定义为INT的别名,使用INT可以代替int,例如:INT a = 10;。

  1. typedef char* PCHAR;

这条语句将char_类型定义为PCHAR的别名,使用PCHAR可以代替char_,例如:PCHAR str = "Hello World!";。

  1. typedef struct tagStudent char name[20]; int age; STUDENT;

这条语句将struct tagStudent类型定义为STUDENT的别名,使用STUDENT可以代替struct tagStudent,例如:STUDENT stu = "Tom", 18 ;。

  1. typedef void (*FUNC_PTR)(int);

这条语句将void ()(int)类型定义为FUNC_PTR的别名,使用FUNC_PTR可以代替void ()(int),例如:FUNC_PTR pFunc = func;。

  1. typedef std::vector IntVec;

这条语句将std::vector类型定义为IntVec的别名,使用IntVec可以代替std::vector,例如:IntVec vec; vec.push_back(1);。

typedef别名的使用场景主要有以下几个方面:

  1. 提高代码的可读性和可维护性,使用别名可以使代码更加易懂,避免使用复杂或难以理解的类型名称。

  2. 简化代码编写,使用别名可以简化代码编写,提高效率。

  3. 便于跨平台编译,使用别名可以在不同的编译器或平台上保持一致的类型名称,避免因不同编译器或平台的差异导致的编译错误。

  4. 便于类型变更和维护,使用别名可以使类型的变更更加方便和安全,减少代码的修改和维护成本。

c++中结构体与共用体。

在C++中,结构体(struct)和共用体(union)都是用户自定义的数据类型,可以用于定义复杂的数据结构。

结构体是一种数据类型,它可以包含多个不同的数据类型,用于描述一个对象或实体的多个属性。结构体中的每个属性称为成员变量,可以是基本数据类型或其他结构体。结构体中的成员变量按照定义的顺序依次排列,每个成员变量都可以通过结构体变量名和成员名来访问。

共用体是一种特殊的结构体,它只能同时存储一个成员变量的值。共用体的成员变量共享同一块内存空间,因此只能访问其中一个成员变量,访问时需要指定成员变量的名称。共用体通常用于节省内存或在不同的数据类型之间进行转换。

以下是结构体和共用体的使用场景:

  1. 结构体通常用于描述具有多个属性的对象或实体,例如:学生、汽车、房屋等。结构体可以将多个属性封装在一起,方便进行数据操作和管理。

  2. 共用体通常用于需要在不同的数据类型之间进行转换的场景,例如:网络通信、文件读写等。共用体可以将不同类型的数据存储在同一块内存空间中,从而避免了数据类型转换时的数据拷贝和类型转换。

  3. 结构体和共用体都可以用于定义复杂的数据结构,例如:树、图等。通过定义结构体和共用体,可以将不同的数据类型组合在一起,构成复杂的数据结构,方便数据的操作和管理。

总之,结构体和共用体都是C++中非常重要的用户自定义数据类型,它们的使用场景非常广泛,可以帮助程序员更加方便和灵活地进行数据操作和管理。

指针、智能指针、方法指针

指针、智能指针和函数指针都是C++中非常重要的数据类型,它们各自有着不同的定义和使用场景,下面分别进行介绍:

  1. 指针

指针是一种特殊的数据类型,它可以存储内存地址。通过指针,程序可以直接访问内存中的数据。指针的定义方式为:类型名 *指针变量名;例如:int *p;定义了一个名为p的整型指针变量。

指针的主要使用场景包括:

  • 动态内存分配和释放
  • 数组访问
  • 传递函数参数
  1. 智能指针

智能指针是一种特殊的指针,它可以自动管理内存的释放。智能指针通常用于动态分配的内存,可以避免程序员忘记释放内存所带来的问题。C++11中提供了两种智能指针:shared_ptr和unique_ptr。

shared_ptr是一种引用计数的智能指针,它会自动记录指向的对象的引用次数,当引用次数为0时,自动释放内存。shared_ptr的定义方式为:shared_ptr<类型>指针变量名;例如:shared_ptr p;定义了一个名为p的整型智能指针变量。

unique_ptr是一种独占所有权的智能指针,它可以确保只有一个指针变量指向对象,并且当指针变量离开作用域时,自动释放内存。unique_ptr的定义方式为:unique_ptr<类型>指针变量名;例如:unique_ptr p;定义了一个名为p的整型独占智能指针变量。

智能指针的主要使用场景包括:

  • 动态内存分配和释放
  • 避免内存泄漏
  1. 函数指针

函数指针是指向函数的指针变量,可以将函数名作为参数传递给函数指针,从而实现函数的动态调用。函数指针的定义方式为:返回类型 (*指针变量名)(参数列表);例如:int (*p)(int, int);定义了一个名为p的指向返回值为int,参数列表为int和int的函数指针变量。

函数指针的主要使用场景包括:

  • 回调函数
  • 函数动态调用
  • 多态实现

总之,指针、智能指针和函数指针都是C++中非常重要的数据类型,它们各自有着不同的定义和使用场景。程序员需要根据具体的需求来选择适合的指针类型,从而实现代码的高效和灵活。

具体使用举例

下面分别以指针、智能指针和函数指针为例,举例说明它们的具体使用场景和用法:

  1. 指针

指针的一个常见使用场景是动态内存分配和释放。例如,程序需要在运行时动态创建一个数组来存储数据,可以使用new运算符分配内存,然后使用指针来访问这个数组:

int size = 10;
int *arr = new int[size];
for (int i = 0; i < size; i++) 
    arr[i] = i;

delete[] arr; // 释放内存

指针的另一个常见使用场景是传递函数参数。例如,程序需要交换两个变量的值,可以使用指针作为函数参数来实现:

void swap(int *a, int *b) 
    int temp = *a;
    *a = *b;
    *b = temp;

int main() 
    int a = 1, b = 2;
    swap(&a, &b);
    return 0;

  1. 智能指针

智能指针的一个常见使用场景是动态内存分配和释放。例如,程序需要动态创建一个对象并使用,可以使用智能指针来管理内存,从而避免内存泄漏:

class MyClass 
public:
    MyClass()  cout << "MyClass constructor" << endl; 
    ~MyClass()  cout << "MyClass destructor" << endl; 
;
int main() 
    shared_ptr<MyClass> p(new MyClass());
    return 0;

智能指针的另一个常见使用场景是避免空指针的问题。例如,程序需要调用一个函数并返回一个指针,但是有可能函数返回的是空指针,这时可以使用智能指针来判断指针是否为空:

c

unique_ptr<int> create_int() 
    int *p = new int(123);
    return unique_ptr<int>(p);

int main() 
    unique_ptr<int> p = create_int();
    if (p) 
        cout << *p << endl;
     else 
        cout << "null pointer" << endl;
    
    return 0;

  1. 函数指针

函数指针的一个常见使用场景是回调函数。例如,程序需要实现一个排序算法,可以通过函数指针来指定排序的方式:

arduino

void bubble_sort(int *arr, int n, bool (*cmp)(int, int)) 
    for (int i = 0; i < n - 1; i++) 
        for (int j = 0; j < n - i - 1; j++) 
            if (cmp(arr[j], arr[j + 1])) 
                swap(arr[j], arr[j + 1]);
            
        
    

bool ascending(int a, int b) 
    return a < b;

bool descending(int a, int b) 
    return a > b;

int main() 
    int arr[] =  3, 1, 4, 1, 5, 9,2, 6, 5, 3 ; int n = sizeof(arr) / sizeof(int); bubble\\_sort(arr, n, ascending); for (int i = 0; i < n; i++)  cout << arr\\[i\\] << " ";  cout << endl; bubble\\_sort(arr, n, descending); for (int i = 0; i < n; i++)  cout << arr\\[i\\] << " ";  cout << endl; return 0; 

```csharp
上面的代码定义了两个比较函数ascending和descending,然后将它们作为函数指针传递给bubble_sort函数,从而实现升序和降序两种排序方式。

c++中并发编程具体如何实现

在C++中,可以通过多线程来实现并发编程。C++标准库提供了一个线程库<thread>,其中包含了创建和管理线程的类和函数。

通过创建多个线程,可以在不同的线程中执行不同的任务,从而实现并发编程。可以使用std::thread类创建一个新线程,将需要在新线程中执行的函数作为参数传递给std::thread类的构造函数。

例如,下面的代码展示了如何使用std::thread类来创建一个新线程并在其中执行一个函数:

cpp

#include <iostream>
#include <thread>

void myFunction() 
    std::cout << "This is myFunction" << std::endl;


int main() 
    std::thread myThread(myFunction);

    myThread.join();

    return 0;

在上面的代码中,myFunction函数会在新线程中执行。myThread.join()会等待新线程执行完毕,然后程序才会继续往下执行。

另外,C++11还提供了一个原子类型std::atomic,它可以保证在多线程并发操作时的原子性,从而避免了多线程竞争导致的数据不一致问题。C++11还提供了一个互斥量std::mutex和一个条件变量std::condition_variable,可以用来实现线程同步和互斥操作。

除了C++标准库提供的多线程机制之外,还可以使用第三方库,比如Boost和Poco等,它们提供了更丰富的多线程功能,例如线程池、定时器、消息队列等,可以更方便地进行并发编程。

上面提到的相关类型,给出具体实现实例

下面是一些具体实现实例:

  1. 使用std::thread创建多个线程并执行不同的函数

cpp

#include <iostream>
#include <thread>
#include <chrono>

void function1() 
    std::cout << "Thread 1 is running" << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    std::cout << "Thread 1 finished" << std::endl;


void function2() 
    std::cout << "Thread 2 is running" << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
    std::cout << "Thread 2 finished" << std::endl;


int main() 
    std::thread t1(function1);
    std::thread t2(function2);

    std::cout << "Main thread is running" << std::endl;

    t1.join();
    t2.join();

    std::cout << "All threads finished" << std::endl;

    return 0;

在上面的代码中,我们创建了两个线程,分别执行function1function2函数。std::this_thread::sleep_for函数可以让线程休眠指定的时间。t1.join()t2.join()语句会等待线程t1t2执行完毕后,程序才会继续往下执行。

  1. 使用std::atomic保证多线程操作的原子性

cpp

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<int> counter(0);

void increment() 
    for (int i = 0; i < 10000; ++i) 
        ++counter;
    


void decrement() 
    for (int i = 0; i < 10000; ++i) 
        --counter;
    


int main() 
    std::thread t1(increment);
    std::thread t2(decrement);

    t1.join();
    t2.join();

    std::cout << "Counter = " << counter << std::endl;

    return 0;

在上面的代码中,我们创建了两个线程t1t2,分别执行incrementdecrement函数。counter是一个std::atomic<int>类型的变量,可以保证多线程操作时的原子性,从而避免了多线程竞争导致的数据不一致问题。

  1. 使用std::mutexstd::condition_variable实现线程同步和互斥操作

cpp

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mutex;
std::condition_variable cv;
bool ready = false;

void worker_thread() 
    std::unique_lock<std::mutex> lock(mutex);
    while (!ready) 
        cv.wait(lock);
    
    std::cout << "Worker thread is running" << std::endl;


int main() 
    std::thread worker(worker_thread);

    std::cout << "Main thread is running" << std::endl;

    
        std::lock_guard<std::mutex> lock(mutex);
        ready = true;
    
    cv.notify_one();

    worker.join();

    std::cout << "All threads finished" << std::endl;

    return 0;

std::lock_guardstd::mutex lock(mutex); 这句的作用是什么

std::lock_guard<std::mutex>是一个RAII风格的互斥锁保护类,用于保护一个临界区,以确保同一时间只有一个线程可以访问该临界区。

lock_guard在构造函数中获取互斥锁,在析构函数中释放互斥锁。因此,使用std::lock_guard<std::mutex>定义的对象,在作用域结束时,会自动释放互斥锁,避免了手动释放互斥锁的麻烦。

在上面的例子中,我们使用std::lock_guard<std::mutex>来保护ready变量的读写操作,防止多线程访问时出现数据竞争的问题。当lock_guard对象的生命周期结束时,互斥锁会自动释放,从而避免了程序员手动释放锁的操作。

函数、虛函数、纯虛函数与析构函数

函数是指一组执行特定任务的代码,可以接受参数并返回值。在C++中,函数可以用于封装重复使用的代码块,提高代码的可读性和可维护性。

虚函数是在基类中声明的,用virtual关键字修饰的成员函数。虚函数可在派生类中重写(override)或重载(overload),实现运行时多态性。使用虚函数可以让基类指针或引用调用派生类的成员函数,实现动态绑定。

纯虚函数是在基类中声明的,没有函数体的虚函数,即在函数声明语句后面加上=0。派生类必须重写所有纯虚函数,否则该派生类也是抽象类。使用纯虚函数可以实现接口(interface),即只声明不定义成员函数。

析构函数是类的特殊成员函数,用于在对象销毁时执行清理工作,例如释放内存、关闭文件等。析构函数的命名规则为~类名(),不接受参数,不返回值。析构函数在对象销毁时自动调用,不需要显式调用。

运用场景:

  • 函数:封装代码块,提高代码的可读性和可维护性。
  • 虚函数:实现多态性,让基类指针或引用调用派生类的成员函数。
  • 纯虚函数:实现接口(interface),只声明不定义成员函数。
  • 析构函数:执行对象销毁时的清理工作,例如释放内存、关闭文件等。

举下具体例子

下面是一个简单的例子,展示了函数、虚函数、纯虚函数和析构函数的使用场景:

c++

#include <iostream>
#include <string>

using namespace std;

// 基类
class Animal 
public:
    // 普通成员函数
    void eat(const string& food) 
        cout << "Animal eats " << food << endl;
    
    // 虚函数
    virtual void move() 
        cout << "Animal moves" << endl;
    
    // 纯虚函数
    virtual void sound() = 0;
    // 析构函数
    virtual ~Animal() 
        cout << "Animal is destroyed" << endl;
    
;

// 派生类1
class Dog : public Animal 
public:
    // 重写虚函数
    void move() override 
        cout << "Dog runs" << endl;
    
    // 实现纯虚函数
    void sound() override 
        cout << "Dog barks" << endl;
    
    // 析构函数
    ~Dog() 
        cout << "Dog is destroyed" << endl;
    
;

// 派生类2
class Cat : public Animal 
public:
    // 重写虚函数
    void move() override 
        cout << "Cat climbs" << endl;
    
    // 实现纯虚函数
    void sound() override 
        cout << "Cat meows" << endl;
    
    // 析构函数
    ~Cat() 
        cout << "Cat is destroyed" << endl;
    
;

int main() 
    Animal* ptr_animal = new Dog(); // 派生类对象可以赋给基类指针
    ptr_animal->eat("meat"); // 调用基类函数
    ptr_animal->move(); // 调用派生类函数
    ptr_animal->sound(); // 调用派生类函数
    delete ptr_animal; // 调用派生类析构函数

    ptr_animal = new Cat(); // 派生类对象可以赋给基类指针
    ptr_animal->eat("fish"); // 调用基类函数
    ptr_animal->move(); // 调用派生类函数
    ptr_animal->sound(); // 调用派生类函数
    delete ptr_animal; // 调用派生类析构函数

    return 0;

在这个例子中,Animal是一个基类,DogCat是两个派生类,都继承了AnimalAnimal中有一个普通成员函数eat(),一个虚函数move(),一个纯虚函数sound(),以及一个析构函数~Animal()DogCat都重写了move()sound(),并实现了各自的析构函数。在main()函数中,我们创建了一个Dog对象和一个Cat对象,并通过基类指针调用它们的成员函数,包括eat()move()sound()。注意,派生类对象可以赋给基类指针,这样就可以通过基类指针调用

c++ 初始化列表

C++的初始化列表是用于初始化成员变量的一种方式,可以在构造函数中通过初始化列表来对类的成员变量进行初始化。

下面是一个简单的例子:

c++

class Person 
public:
  Person(int age, std::string name) : age_(age), name_(name) 
private:
  int age_;
  std::string name_;
;

在这个例子中,构造函数使用初始化列表来对age_name_成员变量进行初始化。注意,成员变量的初始化顺序与它们在类中的声明顺序一致,而不是在初始化列表中的顺序。

初始化列表的使用场景包括:

  1. 初始化成员变量,尤其是const和引用类型的成员变量,因为它们在构造函数中无法被赋值。
  2. 在构造函数中调用基类的构造函数。
  3. 初始化非静态成员对象,如std::mutex,这些对象的构造函数可能会抛出异常,所以最好在初始化列表中初始化它们。

需要注意的是,如果成员变量没有被初始化列表初始化,它们将使用默认构造函数进行初始化,如果没有默认构造函数,会导致编译错误。同时,初始化列表不能对static成员变量进行初始化。

以上是关于C++ 整理的主要内容,如果未能解决你的问题,请参考以下文章

C++基础知识点整理

吐血整理:C++编程语言资源汇总

Google C++ 风格指南内容整理

C++学习之友元整理总结

c++ STL string函数小整理

c++学习知识整理