线程安全问题

2023-08-22

线程安全问题

C++中各种类型的线程安全问题

在C++多线程编程中,主要有以下几类线程安全问题:

数据竞争 - 当多个线程同时访问并试图修改同一处数据时,由于执行顺序不确定造成的数据不一致、数据损坏等问题。
死锁 - 多个线程相互持有对方需要的锁资源而造成的死循环等待。
饥饿 - 一个线程由于优先级太低,始终得不到CPU调度执行而造成的“饿死”。
优先级反转 - 高优先级的线程因等待低优先级线程持有的资源而长时间阻塞。
原子操作失败 - 无法保证一个操作的完整性和原子性。
order 竞争 - 多个线程对同一数据的顺序访问存在不确定性。

主要的解决方法包括:互斥量、信号量、事件、原子操作、线程同步和通信等。
提前设计,注重线程安全,采用合理的同步原语。

解决线程安全问题的多种方案

互斥量(Mutex)

使用互斥量锁保护共享数据的访问,确保同一时刻只有一个线程可以访问该数据:

std::mutex mtx; 

void thread_func() {
  mtx.lock();
  // 访问共享数据
  shared_data++; 
  mtx.unlock();
}

信号量(Semaphore)

控制同时访问共享资源的线程数量

std::semaphore sem(3); 

void thread_func() {
  sem.acquire();
  // 访问共享资源

  sem.release();
}

原子操作(Atomic)

将复合操作作为一个不可分割的原子操作执行

C++中利用原子操作(Atomic Operations)来实现线程安全的一个典型例子是原子计数器:

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

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

// increment循环加1一共2000次 
void increment() {
  for(int i = 0; i < 2000; ++i) {
    counter.fetch_add(1);
	//std::cout << "add counter :" << counter <<std::endl;
  }
}

// decrement循环减1一共1000次
void decrement() {
  for(int i = 0; i < 1000; ++i) {
    counter.fetch_sub(1);
	//std::cout << "sub counter :" << counter <<std::endl;
  }  
}

int main() {

  std::cout << "Start counter: " << counter << std::endl;
  std::thread t1(increment);
  std::thread t2(decrement);

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

  std::cout << "Final counter: " << counter << std::endl;

  return 0;
}

编译及输出结果

编译指令如下
g++ -lpthread atomicSelf.cpp -o thread_example

输出结果如下
Start counter: 0
Final counter: 1000

分析：

使用std::atomic保证对共享counter的原子操作
在主线程中加入t1.join()和t2.join(),确保两个工作线程结束
之后再读取counter的值
这样可以确保计数计算的正确性。

std::atomic和std::thread提供了更简洁合理的多线程控制方法。
相比直接使用pthread来说,C++11的多线程库可以帮助我们更轻松地编写线程安全和高效的多线程程序。

线程同步(Synchronization)

使用条件变量实现线程间的同步配合

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

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

void worker_thread() {
  // 获取数据
  // 对数据进行处理
  std::cout <<"worker_thread" << std::endl;

  // 通知主线程处理完成
  {
    std::lock_guard<std::mutex> lock(mtx);
    ready = true;
    cv.notify_one(); 
  }
}

int main() {

  std::thread worker(worker_thread);

  std::cout << "begin ready :" << ready << std::endl;
  // 等待worker处理完成
  {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{return ready;});
  }
  std::cout << "end ready :" << ready << std::endl;

  // 对结果进行操作
  std::cout << "Worker thread finished." << std::endl;

  worker.join();
  std::cout << "finish ready :" << ready << std::endl;

  return 0;
}

编译及输出结果

编译指令如下
g++ -lpthread cond.cpp -o cond

输出结果如下
begin ready :0
worker_thread
end ready :1
Worker thread finished.
finish ready :1

分析

mutex 互斥锁,保护共享数据
condition_variable 条件变量,线程间同步
unique_lock/lock_guard 上锁
wait 等待条件满足
notify_one 条件通知
通过这些同步原语,可以安全地在线程间通信和同步操作。

condition_variable的灵活性比简单的join要高,可以指定任意同步条件。

这就是一个使用C++标准线程库进行线程同步和通信的示例。

std::condition_variable::notify_one()是什么

std::condition_variable::notify_one()是C++线程编程中一个重要的同步原语。
它的作用是通知一个正在等待该条件变量的线程。

当使用std::condition_variable进行线程同步时,使用步骤一般是:

一个或多个线程等待某个条件,通过cv.wait()挂起自身。
另一个线程在条件成立时,通过cv.notify_one()通知一个等待的线程。
被通知的线程会从wait()函数返回,然后检查条件并继续运行。

例如:

std::mutex mtx;
std::condition_variable cv;
bool data_ready = false;

// 等待线程
cv.wait(lock, []{return data_ready;});

// 通知线程
data_ready = true;
cv.notify_one();

通过notify_one()通知,可以唤醒一个等待该条件的线程,让其检查conditions并继续运行。
notify_all() variant 会通知所有等待线程。
所以std::condition_variable::notify_one()是线程通信的一个重要手段,可以实现复杂的线程同步。

std::condition_variable是C++中进行线程同步和通信的一个重要工具,常见的用法有:

等待条件

std::mutex mtx;
std::condition_variable cv;

cv.wait(lock, []{return ready;}); // 等待ready为true

用wait()挂起线程,直到给定的条件为真。

通知一个线程
1
cv.notify_one(); // 唤醒一个线程
notify_one()会唤醒一个等待该条件的线程。
通知所有线程
1
cv.notify_all(); // 唤醒所有线程
notify_all()会通知所有等待在该条件变量的线程。
设置超时时间
1
cv.wait_for(lock, std::chrono::seconds(1), []{return ready;});
wait_for()可以设置超时时间,在指定时间后会自动返回。
捕捉等待期间的异常
1
cv.wait(lock, []{return ready;}, [&]{handleError();});
通过传递异常处理器,可以处理wait()期间抛出的异常。

综上,condition_variable通过灵活的等待策略和通知机制,可以帮助实现强大的多线程同步。

unique_lock/lock_guard 上锁是什么

std::unique_lock和std::lock_guard都是C++中实现互斥锁的RAII类。

std::unique_lock实现了移动语义和所有权的独占锁。主要功能有:

构造时自动上锁
支持移动语义(移动构造函数和移动赋值操作符)
release()可以手动释放锁
支持定时上锁try_lock_for()和try_lock_until()
支持条件变量wait(),允许在等待时解锁
析构时自动解锁

所以unique_lock功能非常全面和灵活。

std::lock_guard是一个非拷贝非移动的简单锁封装类。主要用于通过RAII保证互斥锁一定会被释放。主要功能是:

构造时自动上锁
不允许拷贝构造和移动构造
析构时自动解锁

lock_guard不能手动解锁,也不能和条件变量一起使用。但代码量少,通常用在简单的局部锁场景。

两者都是通过RAII来保证加锁和解锁成对执行,避免死锁。
unique_lock功能更全面,lock_guard使用更简单。

展开全文 >>

C++中级问题记录

2023-08-22

C++进阶问题整理

什么是RAII原则？它有什么作用？

RAII(Resource Acquisition Is Initialization) 是 C++ 中一种资源管理方法,主要通过构造和析构来自动获取和释放资源。

其原则是:

在对象构造时获取所需的资源
在对象析构时自动释放所持有的资源

RAII的主要作用有:

自动管理资源生命周期,避免资源泄露
RAII对象会在作用域结束时被析构,从而自动释放资源,无需手动管理资源。
将资源管理与使用逻辑分离
通过RAII封装资源,可以将资源的获取、释放与业务逻辑分离,保持代码整洁。
通过构造异常安全性(Constructive Exception Safety)
使用RAII在构造函数获取资源,析构函数释放,可以保证即使出现异常,资源也会被释放。
阻止重复获取(Double Acquisition)
RAII对象封装了独占的资源获取方式,可以阻止对同一资源的重复获取。

C++中智能指针、容器、mutex等都是基于RAII实现的,它是C++管理资源的重要方式。

什么是RTTI信息？

RTTI(RunTime Type Information)即运行时类型信息,是C++中实现运行时判断类型的一种机制。

主要提供以下几方面的信息:

typeid运算符:可以在运行时获取对象的类型
dynamic_cast:通过类型信息进行安全的向下转换
type_info类:包含类型的名称等信息

RTTI工作原理:
编译器会为包含虚函数的类产生类型信息(对类进行name mangling),存储于可执行文件中。
运行时通过此信息来实现类型判断与转换。

RTTI的主要作用有:

判断和比较运行时对象的类型
安全地向下转换指针或引用
实现一些设计模式如访问者模式

所以RTTI允许程序在运行时确定对象类型,通过类型信息进行更安全灵活的代码逻辑处理。
需要注意RTTI会带来额外开销,应该仅在需要时使用。

RTTI的简单示例:

#include <typeinfo>
#include <iostream>
using namespace std;

class Base {
  virtual void foo() {} 
};

class Derived : public Base {};

int main() {
  Derived d; 
  Base* b = &d;

  // 使用typeid获取对象运行时类型
  if(typeid(*b) == typeid(Base)) { 
    cout << "b is Base" << endl;
  } else {
    cout << "b is Derived" << endl; 
  }

  // 使用dynamic_cast进行安全向下转换
  Derived* d2 = dynamic_cast<Derived*>(b);
  if(d2) {
    cout << "downcast success" << endl;
  } else {
    cout << "downcast failed" << endl;
  }

  // 获取类型名称
  cout << "name: " << typeid(*b).name() << endl;

  return 0;
}

编译：

1	g++ -o rtii rtii.cpp --std=c++0x

输出:

1
2
3

b is Derived
downcast success
name: 7Derived

实现了在运行时判断和转换对象类型,以及获取类型名信息。
RTTI虽好用,但需要注意它带来的额外开销。

构造函数和析构函数的执行顺序是什么?

在C++中,构造函数和析构函数的执行顺序遵循以下原则:

构造函数的执行顺序按照继承关系从基类到派生类。
析构函数的执行顺序与构造函数相反,从派生类到基类。
执行顺序还受到虚继承的影响。

一个具体的执行顺序示例:

#include <iostream>

class Base {
public:
    Base() {
        std::cout << "Base constructor" << std::endl;
    }

    ~Base() {
        std::cout << "Base 析构" << std::endl;
    }
};

class Middle : public Base {
public:
    Middle() {
        std::cout << "Middle constructor" << std::endl;
    }
    ~Middle() {
        std::cout << "Middle 析构" << std::endl;
    }
};

class Derived : public Middle {
public:
    Derived() {
        std::cout << "Derived constructor" << std::endl;
    }
    ~Derived() {
        std::cout << "Derived 析构" << std::endl;
    }
};

int main() {
    Derived d;
    return 0;
}

输出

Base constructor
Middle constructor
Derived constructor
Derived 析构
Middle 析构
Base 析构

构造函数需要先构造父类,析构相反。这确保类的资源可以正确初始化和释放。

虚继承和多继承情况下顺序更复杂,要分析父子关系来确定执行顺序。

虚继承对构造和析构的影响

虚继承对构造和析构顺序的影响有一定复杂性。
虚继承只会影响不同基类之间的先后顺序,不会改变基类先于派生类的规则。

虚继承对构造和析构顺序的影响更具体应该是:

虚基类总是先于非虚基类构造和析构,不管在继承列表中的顺序
派生类会先构造虚基类部分,再构造非虚基类和自己的部分
基类仍然先于派生类构造和析构

C++类成员在内存中是怎样存储的?

C++类的成员变量通常会按以下方式存储在内存中:

非静态成员变量属于类的每个实例,会与实例一起分配在堆或栈上。它们不会共享内存。
静态成员变量属于整个类,只有一个副本,通常放在程序的静态存储区(数据段或bss段)。所有类实例都共享这段内存。
成员函数也属于整个类,只有一份代码拷贝。它们通常放在代码段中。通过this指针找到调用它的类实例。
构造函数和析构函数是特殊的成员函数,按成员函数方式存储。
虚函数的虚函数表储存在共享内存中,每个类实例都有一个指向虚函数表的指针。
继承的情况下,子类的成员会放在基类成员的后面,先父类后子类。

所以简单来说,非静态成员独享内存,静态成员和成员函数共享内存。虚函数通过虚函数表达到多态。

c++普通函数、局部变量、全局变量在内存中怎么存储

在C++中,普通函数、局部变量和全局变量在内存中的存储方式如下:

普通函数:存储在代码段中。代码段是一块存储只读指令的内存区域,用于存放程序执行所需的代码。函数的机器代码被编译器放在代码段中。
局部变量:存储在栈中。栈是一块先进后出的内存区域,用于存放函数调用时创建的临时变量。局部变量随函数调用创建,随函数返回被自动释放。
全局变量:存储在数据段中。数据段是一块存储程序中已初始化的全局变量的内存区域。全局变量在程序开始时分配,在程序结束时释放。不同函数里访问的是同一份全局变量的内存。
常量:字符串常量存储在代码段中;其他常量如整型常量,如果是全局的,存储在数据段中;如果是局部的,存储在栈中。
静态变量:存储在数据段中,但有局部变量的生命周期。

所以简单说,函数在代码段,局部变量在栈中,全局变量和静态变量在数据段中。它们在内存的布局和生命周期各不相同。

存储位置和生命周期的关系c++

在C++中,变量的存储位置和生命周期有着密切的关系:

栈区:存放局部变量,函数的参数,临时变量等。其生命周期为:进入栈时分配内存,退出栈时(函数返回)自动释放内存。
堆区:通过new关键字申请的内存块。其生命周期为:执行new时分配内存,执行delete时释放内存,需要程序员控制。
静态区:存放全局变量和静态变量。其生命周期为:程序的加载时分配内存,程序结束时释放内存。
常量区:存放 const 修饰的变量。其生命周期为:程序的加载时分配内存,程序结束时释放内存。
代码区:存放函数体的二进制代码。其生命周期为:程序加载时分配内存,程序结束时释放内存。

所以,栈区和堆区由程序员控制生命周期,静态区和常量区生命周期由系统控制,栈区和堆区内存需及时释放避免泄漏。存储位置的不同导致它们生命周期范围不同。

什么是内存泄漏和野指针?如何避免?

内存泄漏和野指针是C++编程中常见的两类内存问题。

内存泄漏是指程序中已动态分配的堆内存由于某种原因未被释放,在程序执行结束后也未被系统回收,造成内存的浪费。
内存泄漏的主要原因是忘记手动释放堆内存或者失去了指向堆内存的指针。
避免内存泄漏的方法是及时释放new分配的内存,使用智能指针等。

野指针是指指向非法内存地址的指针。它可能是一个未初始化的指针、已经释放的堆内存地址、或者非法访问其他内存空间的地址。
野指针的主要问题是可能会造成程序异常和崩溃。
避免野指针的方法是保证每个指针都在合法内存范围内,防止越界访问,以及在释放对象后将指针置为空。

总结一下,内存泄漏是持续占用未释放内存,野指针是非法访问内存。
我们要及时释放内存,初始化和判断指针有效性,才能避免这两类问题。

什么是右值？

在C++中,右值(rvalue)是指储存在寄存器而不是内存中的临时对象或直接输入的数据值。

主要有以下三种情况:

字面量常量,如 10, 3.14, “abc”等
临时对象,如函数的返回值或运算结果
将要被销毁的对象

右值具有以下特点:

不具名
不可取地址
无法修改
只能移动,无法复制

右值主要出现在赋值、初始化和传参的右边。
例如:

int x = 10; // 10就是一个右值

string s1 = s2; // s2是右值

foo(x + 1); // x + 1结果是右值

右值引用可以让右值直接传递给函数内部,避免复制开销。
理解右值的概念对学习移动语义很重要。

std::vector的push_back和emplace_back比较

std::vector的push_back和emplace_back都是用来向vector尾部插入元素

主要区别在于:

push_back通过拷贝或移动方式插入元素,emplace_back则通过就地(in-place)构造方式插入。
push_back只能直接插入元素,emplace_back可以传入构造参数进行就地构造。
当元素类型为类对象时,emplace_back避免了不必要的拷贝或移动操作。
当需要使用多个参数构造对象时,emplace_back更加方便。

例如:

std::vector<std::string> v;

v.push_back("abc"); // 拷贝插入
v.push_back(std::string("abc")); // 移动插入 

v.emplace_back("abc"); // 就地构造
v.emplace_back(3, 'a'); // 使用多个参数构造

std::vector的emplace_back方法可以通过完美转发(perfect forwarding)将多个参数传递给元素类型的构造函数,以就地(in-place)方式构造出一个元素并插入vector。

例如:

1
2
3

std::vector<std::string> v;

v.emplace_back(3, 'a');

这里发生了以下操作:

emplace_back把参数(3, ‘a’)完美转发给std::string的构造函数
使用这些参数调用std::string的构造函数std::string(size_t count, char ch)来构造一个字符串
然后这个通过参数构造出来的字符串被就地插入到vector中
所以v.emplace_back(3, 'a');会向vector中插入一个内容为”aaa”的字符串。

一个完整的示例代码

#include <memory>
#include <iostream>
#include <vector>

int main()
{
	std::vector<std::string> v;
	v.emplace_back("abc"); // 就地构造
	v.emplace_back(3, 'a'); // 使用多个参数构造
	
	for(auto& it : v) { // 使用引用接收,避免拷贝
		std::cout << "val : " << it <<std::endl;
	}
	
	return 0;
}

编译和运行

编译
g++ -o vecuse vecuse.cpp -std=c++2a

运行
val : abc
val : aaa

emplace_back避免了拷贝和移动操作,可以高效地用多个参数直接构造出元素并插入。这对一些需要多参数构造的类型很有用。

总结来说,对于类对象,emplace_back通常更加高效,因为它可以就地构造,避免拷贝操作。所以优先考虑使用emplace_back来插入元素。

展开全文 >>

C++11基础问题整理记录

2023-08-22

c++基础问题整理

背景

对常见的基础问题进行一个汇总整理

什么是多态？如何实现多态？

多态是面向对象编程中的一个重要概念，它指的是通过一个基类指针或引用调用一个虚函数时，会根据具体对象的类型来调用该虚函数的不同实现。
在多态中，相同的操作可以作用于不同的对象，而具体执行的操作则取决于对象的类型和特性。

在C++中，要实现多态，需要满足以下两个条件：

必须通过基类的指针或者引用调用虚函数
被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

什么是虚函数？为什么要使用虚函数？

虚函数是C++中用于实现多态(polymorphism)的机制。核心理念就是通过基类访问派生类定义的函数。

在有动态分配堆上内存的时候，析构函数必须是虚函数，但没有必要是纯虚的。

想要构成多态，必须使用虚函数，借助于虚函数表来实现，
我们也知道，虚函数表是为了让父类引用子函数对象实现多态的。

虚函数的实现原理？

虚函数的实现原理主要涉及两部分:

虚函数表(Virtual Table)
编译器会为包含虚函数的类建立一个虚函数表(Virtual Table)。这个表中存放了该类所有的虚函数的入口地址。
虚表指针(Virtual Pointer)
包含虚函数的类在每个对象中都有一个虚表指针(this指针就是),该指针指向该类的虚函数表。
当调用对象的虚函数时,通过这个虚表指针先找到对应的虚函数表,再在虚函数表中取得要调用的虚函数的实际入口地址,然后进行调用。

这样当对基类指针调用虚函数时,就可以根据这个指针动态得到派生类的覆盖实现版本的虚函数。
总结一下虚函数的调用过程:

通过对象的虚表指针找到虚函数表
在虚函数表中找到函数名对应的函数入口
跳转到该入口地址进行函数调用
这就是C++虚函数实现多态的基本原理和方法。

什么是虚函数表？

虚函数表是指在每个包含虚函数的类中都存在着一个函数地址的数组。
当我们用父类的指针来操作一个子类的时候，这张虚函数表指明了实际所应该调用的函数。
C++的编译器保证虚函数表的指针存在于对象实例中最前面的位置，这样通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。

什么是继承？继承有哪些特性？

继承是面向对象软件技术当中的一个概念，与多态、封装共为面向对象的三个基本特征。
继承可以使得子类具有父类的属性和方法或者重新定义，追加属性和方法。

在C++中，继承有以下几个特性：

派生类可以重载基类中的虚函数。
派生类可以访问基类的成员。
派生类可以新增成员函数和成员变量。
派生类可以作为基类的友元函数调用。

派生类可以访问基类的public, protected, private成员吗？

派生类不能直接访问基类的private成员，若要访问必须使用基类的接口，即通过其成员函数。
派生类对基类成员的访问权限，与是public 、 protected 、 private继承类型没关系，仅仅与基类中成员的权限属性有关系：派生类能访问基类的public和protected成员，不能访问private成员。

继承类型对派生类的影响是什么？这三种继承类型的区别是什么？

在C++中，继承有三种类型：公有继承（public）、私有继承(private)、保护继承(protected)。
派生从已有类产生新类的过程就是类的派生。
产生的新类就叫做派生类（derived class）。
被重用的原有类称为基类（base class）。
派生类不会影响到基类的结构。

在C++中，公有继承、私有继承和保护继承的区别如下：

公有继承：基类中所有public成员在派生类中都为public属性；基类中所有protected成员在派生类中都为protected属性；基类中所有private成员在派生类中都为private属性。派生类对象可以访问基类中的公有成员和保护成员，但是不能访问基类的私有成员。
私有继承：基类中所有public和protected和private成员在派生类中都为private属性。派生类对象可以访问基类中的公有成员和保护成员，但是不能访问基类的私有成员。
保护继承：基类中所有public和protected成员在派生类中都为protected属性；基类中所有private成员在派生类中都为private属性。派生类对象可以访问基类中的公有成员和保护成员，但是不能访问基类的私有成员。

派生类可以作为基类的友元函数调用

派生类可以作为基类的友元函数调用。
在C++中，如果一个函数被声明为某个类或结构体的友元函数，那么这个函数就可以访问该类或结构体的所有成员（包括私有成员）和所有成员函数。
因此，派生类可以作为基类的友元函数调用，以便访问基类中的私有成员。

友元函数

友元函数是指某些虽然不是类成员却能够访问类的所有成员的函数。类授予它的友元特别的访问权。
通常同一个开发者会出于技术和非技术的原因，控制类的友元和成员函数（否则当你想更新你的类时，还要征得其它部分的拥有者的同意）。

在C++中，如果要声明函数为一个类的友元，需要在类定义中该函数原型前使用关键字 friend

示例代码如下：

#include <iostream>

using namespace std;

class Base {
    friend class Derived; // 声明Derived为友元类
    int x;

public:
    Base() : x(0) {}

    void showX() {
        cout << "Base x = " << x << endl; 
    }
};

class Derived : public Base {
public:
    void accessBaseX() {
        x = 100; // 作为友元,可以访问Base的私有成员
    }
};

int main() {
    Derived d;
    d.accessBaseX(); // 派生类访问基类的私有成员
    d.showX(); // 输出 Base x = 100
}

在这个例子中,我们将派生类Derived声明为基类Base的友元类。
这样,Derived就可以直接访问Base的私有成员x。

在main函数中,我们通过派生类对象调用accessBaseX()函数修改了基类的x,然后再通过showX()函数输出x,说明派生类作为友元确实可以访问基类的私有成员。

如果在class定义中没有显式指定访问权限,则默认为private

也就是说,如果写成这样:

class MyClass {
  int x; 
  void func();
};

那么x和func()默认都是private的,不能在class外部直接访问。

需要改成

class MyClass {
public:
  int x;
  void func();  
};

才能让x和func()成为public,可以在class外部访问。

所以C++类的默认访问权限是private。这与struct不同,struct默认是public。

这点需要注意,如果忘记写public,可能会导致意料之外的不可访问错误。

什么是抽象类和接口？它们之间有什么区别？

抽象类和接口都可以包含抽象方法,但是它们之间有以下几点主要区别:

在C++中,抽象类和接口的主要区别有:

(1)抽象类使用纯虚函数,接口使用纯虚函数加虚继承
(2)抽象类可以有构造函数,接口不能有
(3)抽象类可以包含普通函数的实现,接口所有函数都是纯虚函数
(4)一个类只能继承一个抽象类,但可以同时继承多个接口
(5)抽象类强调对类的抽象,接口强调对行为的抽象

总结一下:

抽象类体现的是”是什么”的关系,一个子类只能继承一个抽象类
接口体现的是”能做什么”的关系,一个类可以同时实现多个接口
抽象类与子类是 is-a 关系,接口与实现类是 has-a 关系。

抽象类示例

示例代码如下：

#include <iostream>

// 抽象类Shape
class Shape {
public:
  virtual void draw() = 0; // 纯虚函数,定义抽象方法
};

// 继承抽象类Shape
class Circle : public Shape {
public:
  void draw() { // 实现抽象方法
    std::cout << "Drawing a circle" << std::endl; 
  }
};

class Rectangle : public Shape {
public:
  void draw() {
    std::cout << "Drawing a rectangle" << std::endl;
  }
};

int main() {
  Circle c;
  Rectangle r;

  c.draw(); // 调用子类实现的抽象方法
  r.draw();

  return 0;
}

在C++中,抽象类包含至少一个纯虚函数,它只定义方法签名,不实现函数体。

子类在继承抽象类时,必须实现抽象类中的所有纯虚函数,否则子类也变为抽象类。

上面代码中,Shape类包含一个纯虚函数draw(),作为抽象方法。 Circle和Rectangle继承自Shape,并重写draw()方法,实现了抽象方法。

这样就可以通过子类对象调用抽象方法了。

子类在继承抽象类时,必须实现抽象类中的所有纯虚函数,否则子类也变为抽象类

在C++中,如果子类继承了抽象类,但是没有实现抽象类中的所有纯虚函数,那么这个子类也会变成抽象类。

但是子类可以选择只重写抽象类中的部分纯虚函数,而保留未实现的纯虚函数的纯虚性。
这时子类依然是一个抽象类,不能实例化对象,需要再被其他类继承实现剩余的纯虚函数。

例如:

class Abstract {
public:
  virtual void func1() = 0;
  virtual void func2() = 0;
};

class Subclass : public Abstract {
public:
  void func1() {
    // implement func1
  } 
  // 不实现func2(),它仍然是纯虚函数
};

这里SubClass只重写了func1(),func2()仍为纯虚函数。
那么SubClass仍然是一个抽象类,需要后续完全实现两个纯虚函数才能成为具体类。

所以结论是:
子类必须实现抽象类的所有纯虚函数,才能成为具体类
子类可以只重写部分纯虚函数,保留其抽象类性质

接口示例

好的,在C++中可以通过纯虚函数和虚继承来实现接口,示例代码如下:

#include <iostream>

// 定义接口
class Interface {
public:
  virtual void method1() = 0;
  virtual void method2() = 0;
};

// 实现类A
class ImplA : virtual public Interface {
public:
  void method1() override {
    // 方法1实现
    std::cout << "ImplA::method1" << std::endl;
  }
  
  void method2() override { 
   // 方法2实现
    std::cout << "ImplA::method2" << std::endl;
  }
};

// 实现类B 
class ImplB : virtual public Interface {
public:
  void method1() override {
    // 方法1实现
    std::cout << "ImplB::method1" << std::endl;
  }
  
  void method2() override {
    // 方法2实现
    std::cout << "ImplB::method2" << std::endl;
  }  
};

// 使用接口和实现类
void func(Interface* p) {
  p->method1();
  p->method2(); 
}

int main() {
  ImplA ia;
  ImplB ib;
  
  func(&ia);
  func(&ib);
  
  return 0;
}

通过Interface类中的纯虚函数定义接口,ImplA和ImplB虚继承Interface并实现这些纯虚函数。

func()函数通过Interface指针调用方法实现解耦。

这就是C++中使用纯虚函数和虚继承实现接口的基本方式。

重载与重写

在C++中,重载(overloading)和重写(overriding)是两个不同的概念:
重载(overloading)指的是在同一个类中有相同名称但参数列表不同的多个函数。它必须发生在类内,是一种静态绑定。

例如:

class Foo {
  public void func(int a) {
    //do something
  }
  
  public void func(int a, int b) {  
    //do something else
  }
}

重写(overriding)指派生类重新定义基类的虚函数,参数列表必须完全相同。它涉及基类和派生类,是一种动态绑定。
例如:

class Base {
  virtual void func() {
    //do base stuff
  } 
}

class Derived: public Base {
  void func() { 
    //do derived stuff
  }
}

重载是编译期决定的静态绑定,重写是运行期通过动态绑定来调用派生类的函数实现。
简记为:

重载 - 相同名,不同参;静态绑定
重写 - 相同签名;动态绑定

重写虚函数的时候该不该加override?

在C++中重写虚函数时加override关键字和不加的区别是:

加override可以防止意外重载
如果子类恰好定义了和父类同名的虚函数,但参数不同,就变成重载了,加override可以让编译器报错,防止这种情况。
加override可以检查父类是否有该虚函数
如果父类没有要重写的虚函数,加override会报错,防止重写错误。
加override可以提示维护者这个函数正在重写父类虚函数
增加代码可读性。

所以通常情况下,建议在重写虚函数时加上override关键字,既可以避免一些错误,也可以让代码更清晰。

但是有以下情况可以不加:

子类不会定义和父类同名的重载函数。
已确保父类有该虚函数需要重写。
老代码使用C++11之前的标准,不支持override。

所以是否加override可以根据具体情况来决定,建议在可能产生歧义或错误的情况下加上,提高代码质量。

C++中的静态绑定和动态绑定

C++中静态绑定和动态绑定:

静态绑定(Static Binding):

函数调用在编译时就已经确定了调用的函数地址
调用的是哪个函数是在编译期静态决定的
C++中所有非虚函数的调用都是静态绑定

动态绑定(Dynamic Binding):

函数调用直到运行时才确定调用的函数地址
调用哪个虚函数版本是在运行时动态决定的
C++中所有虚函数的调用都是动态绑定

例如:

void foo(Base* b) {
  b->nonVirtualFunc(); // 静态绑定,编译期已确定调用Base::nonVirtualFunc
  b->virtualFunc(); // 动态绑定,运行时决定调用Base或Derived的版本
}

静态绑定优点是调用效率高,缺点是灵活性差。动态绑定正相反。
静态绑定主要用于非虚函数和模板函数,动态绑定用于虚函数以实现运行时多态。

什么是内联函数?内联函数和宏的区别是什么?

内联函数(inline function)就是在函数调用点进行函数体扩展 substituted 的函数。

将函数设置为内联函数的好处是:

内联函数在编译时进行展开,减少了函数调用的开销。
相比宏,内联函数在编译时会进行类型检查,增强了类型安全。

内联函数和宏主要有以下几点区别:

宏是文本替换,没有类型检查;内联函数在编译时会类型检查。
宏可能会造成重复定义问题;内联函数在链接时会去重复。
宏可以接受任意语句作为参数;内联函数只接受和函数形式相匹配的参数。
内联函数在Debug模式下不一定会内联,而宏总是展开的。

所以总结为,相比宏,内联函数有类型检查,避免重复定义错误,但是编译器可能不一定内联,需要根据优化级别。
内联函数更安全,宏可能带来更高效的内联。

C++中虚析构函数的作用及需要场景

在C++中,虚析构函数的作用是:
当删除一个派生类对象时,调用派生类的析构函数,确保释放派生类的资源。

场景:

基类指针指向派生类对象,通过基类指针删除对象时,需要调用派生类的析构函数

1 2	Base* p = new Derived(); delete p; // 需要调用Derived析构函数释放资源

包含虚函数的类需要声明虚析构函数

class Base {
public:
  virtual void foo() {}
  virtual ~Base() {} // 虚析构函数
};

有纯虚函数的类需要声明纯虚析构函数

class Base {
public:
  virtual void foo() = 0; 
  virtual ~Base() = 0;
};

拥有虚基类的类需要声明虚析构函数

1
2
3

class Derived : virtual public Base {
  ~Derived() {} // 需要是虚析构
};

所以包含虚函数或虚继承的类,都需要声明虚析构函数,否则删除派生类对象时可能导致未释放资源。

虚基类

在C++中,虚基类是一种让基类只继承一次的机制。

对于带有虚基类的继承:

虚基类只会继承一次,不管出现多少次虚继承
派生类的对象中只会包含一份虚基类成员
虚基类指针在各个派生类中都是共享的

示例:

class Base {
public:
  Base() { cout << "Base" << endl; }
};

class A : virtual public Base {};

class B : virtual public Base {}; 

class C : public A, public B {};

// C对象在初始化时只会调用一次Base构造
C c; // 输出 "Base"

使用virtual关键字声明虚基类。
虚基类机制可以解决多继承时基类被继承多次的问题。
需要注意的是,虚继承会增加对象大小并降低构造效率。应该在确实需要共享基类时使用。

虚基类和虚继承的关系？什么情况下用虚基类？

虚基类和虚继承的关系是:

虚继承(Virtual Inheritance)是一种继承方式,用于解决多重继承时重复继承的问题。
虚基类(Virtual Base Class)是虚继承的基类,通过虚继承后,该基类就称为虚基类。

使用虚基类的典型情况:

需要解决多重继承 Repeat Inheritance 问题时。
例如类A,B都继承自Base,C继承A,B,则Base会重复继承两次,这时可以将Base标记为虚基类。
需要在继承链中共享基类数据时。
虚基类只会继承一次,所以派生类中只有一份基类数据的拷贝。
基类需要动态绑定或RTTI信息时。
虚基类可以正确实现动态绑定和RTTI的表现。
某些设计模式需要重复继承同一抽象基类。
如Visitor模式中,各个具体类都需要继承抽象访问者类。

总之,虚继承是一种继承机制,虚基类是进行虚继承的基类。
当需要重复继承同一基类时,将其设置为虚基类以实现只继承一次。

例如类A,B都虚继承自Base,C继承A,B, 那么ABC共享一份Base数据吗？

如果是这样:

class Base {};

class A : virtual public Base {};

class B : virtual public Base {};

class C : public A, public B {};

则A、B、C会共享同一份Base数据,因为Base被虚继承了。

但是如果是:

class Base {};

class A : public Base {}; 

class B : public Base {};

class C : public A, public B {};

则A、B各自含有一份Base数据的拷贝,C会包含两份Base,因为Base没有被虚继承。

总结
所以,要使得多重继承链上共享同一份基类数据,该基类必须被所有中间链上的类使用虚继承,否则还是会出现重复实例。

展开全文 >>

C++11新特性记录.md

2023-08-22

C++11重要的新特性

自动类型推导:auto、decltype

C++11中新增了自动类型推导的功能,包括auto和decltype两种方式。它可以减少代码中的重复定义,使代码更简洁。

auto
auto可以根据初始化表达式自动推导变量类型。例如:

auto x = 1; // x被推导为int
auto y = 1.0; // y被推导为double
std::vector<int> vec{1,2,3};
auto iter = vec.begin(); // iter被推导为vector<int>::iterator

auto在需要定义长类型名的场景下非常有用。

decltype
decltype可以获取一个表达式的类型。例如:

int x = 1;
decltype(x) y = 2; // y的类型与x相同,为int

std::vector<int> vec{1,2,3}; 
decltype(vec)::iterator iter = vec.begin(); // iter的类型为vector<int>::iterator

decltype对于获取模板表达式的结果类型也很有用。

总结:

auto用于变量类型推导,减少重复代码
decltype用于表达式类型获取,可处理模板表达式

合理利用auto和decltype可以简化代码,消除类型重复定义。但也需要避免过度使用,降低代码可读性。

统一初始化语法:{}

C++11在初始化方面做了统一和增强,使用{}可以统一多种初始化方式。

主要特点:

将构造函数初始化和均值初始化统一起来:

int x(1); //调用构造函数初始化 
int y{1}; //也是调用构造函数初始化

int x = 1; //均值初始化
int y = {1}; //现在也可以用{}均值初始化

列表初始化可以避免窄化转换:

1 2	int x = {1.1}; //错误,double到int有窄化转换 int y{1.1}; //正确,由编译器选择匹配的构造函数

强制指定初始化方式:

1 2	vector<int> v(10, 1); //调用构造函数初始化 vector<int> v{10, 1}; //调用重复元素初始化

初始化类对象:

1
2
3

class A {...};
A a(1, 2); //调用构造函数 
A b{1, 2}; //也是调用构造函数

初始化数组:

1 2	int arr[3] = {1, 2, 3}; int arr[3]{1, 2, 3}; //现在也可以使用{}初始化数组

总结:{}可以统一许多初始化方式,使代码更简洁,也能避免一些问题。

Lambda表达式和函数对象包装器(如std::function)

C++11中引入了lambda表达式和std::function,可以方便地定义和使用函数对象。

Lambda表达式
Lambda表达式可以直接在代码中定义匿名函数,例如:
1
2
3
auto add = [](int x, int y) {
return x + y;
};
自动根据参数和返回值类型推导出函数签名。Lambda可捕获外部变量,支持多种形式。
std::function
std::function是一个通用的函数对象包装器,可以包装函数指针、Lambda表达式等为统一的函数对象。
例如:
1
2
3
4
5
std::function<int(int,int)> func = [](int x, int y) {
return x + y;
};

int result = func(1, 2);
std::function提供统一的函数调用接口,可以对任意可调用对象进行存储、复制和调用操作。

两者结合使用可以实现类似策略模式的效果:

std::vector<std::function<void()>> handlers; 

handlers.push_back([](){ 
  // do something
});

for (auto& handler : handlers) {
  handler(); // 调用函数对象
}

这里是一个完整的示例

#include <functional>
#include <iostream>

// 普通函数
int add(int a, int b) {
  return a + b;
}

int main() {

  // 函数指针
  int (*funcPtr)(int, int) = &add;

  // lambda表达式
  auto lambda = [](int a, int b) {
    return a + b; 
  };

  // 用std::function包装函数指针
  std::function<int(int, int)> func1 = funcPtr;

  // 用std::function包装lambda表达式
  std::function<int(int, int)> func2 = lambda;

  // 调用包装后的函数对象
  int x = func1(1, 2);
  int y = func2(3, 4);

  std::cout << x << std::endl;
  std::cout << y << std::endl;

  return 0;
}

编译与运行

编译
g++ -o usehan usehan.cpp -std=c++0x

运行
3
7

上面代码定义了一个普通函数add,然后用函数指针和lambda表达式分别配合std::function进行了包装,使其可以通过统一函数调用的方式使用。
这个示例演示了std::function可以包装函数指针和lambda表达式,作为函数对象使用的方法。

总结:

Lambda方便定义匿名函数
std::function提供函数对象的统一封装和调用方式
两者结合可以实现函数的存储与延迟执行

强类型枚举类enum class

C++11在enum的基础上新增了enum class,它被称为强类型枚举(Scoped Enumeration)。

相比普通enum,enum class有以下特点:

enum class的枚举值需要进行显式转换才能进行运算。

enum class Color { RED, GREEN, BLUE}; 

Color c = Color::RED;
if (c == Color::RED) { // 需要比较相同类型
  
}
int i = (int)c; // 需要显式转换才能进行算术运算

强类型enum不会将枚举值泄露到外部作用域。

1 2	enum class Secret { CODE1, CODE2, CODE3 }; int i = CODE1; // 错误,CODE1未定义

使用强类型enum可以避免不同enum命名冲突。

1 2	enum class Fruit { Apple, Banana }; enum class Color { Apple, Orange }; // 不会冲突

总结:

使用enum class定义强类型enum
需要进行显式转换才能混合运算
避免命名冲突,增强封装

enum class总体上比普通enum更安全,适合对枚举进行更严格的控制。

nullptr和强制类型转换操作

C++11中nullptr和强制类型转换操作的主要新特性如下:

nullptr

引入nullptr关键字
C++11引入nullptr关键字来表示空指针,以代替过去的0或NULL。
nullptr是指针类型,不能隐式转换为整数,避免了空指针与0的混淆。
nullptr避免了整数0与空指针的混淆。0可以隐式转换为指针,但nullptr不行。
nullptr是指针的专属空值,而强制类型转换如(int)nullptr会产生未定义行为。
nullptr可以隐式转换为任何指针类型,如int* p = nullptr; 不需要强制转换。
用nullptr初始化智能指针可以正确构造空值,而使用0可能会导致编译错误。

nullptr支持指针类型的重载
nullptr可以用于指针类型的函数重载,而0不行。

void foo(int) {..} 
void foo(char*) {..}

foo(0); // 调用foo(int)
foo(nullptr); // 调用foo(char*)

nullptr的类型推导
在模板类型推导中,nullptr推导为std::nullptr_t类型,而不是整数类型。

template <typename T>
void foo(T t);

foo(0); // T被推导为int
foo(nullptr); // T被推导为std::nullptr_t

总结:

nullptr是指针专属的空值标记
避免了整数0与空指针的混淆
不能进行数值运算,只能转换为指针类型

强制类型转换

强制类型转换的新语法
C++11使用括号替代老的func风格强制转换,如:(int)x。
强制转换为bool不再是隐式转换
要将其他类型转换为bool,必须使用直接初始化或静态_cast。
强制转换为bool会产生编译警告
编译器会针对其他整数或指针类型强制转换为bool产生警告。
强制类型转换需遵循const转换规则
转换结果类型必须遵循const转换兼容规则。

总结起来,C++11简化和规范了nullptr及强制类型转换的使用,使其更安全和一致。这是现代C++的重要改进。

标准线程库

C++11提供了标准线程库,包含在头文件中,主要组成部分包括:

std::thread - 代表一个执行线程的对象。可以通过构造函数和thread对象启动新线程:

void foo() {
  // 线程执行函数
} 

std::thread t(foo); // 创建新线程 
t.join(); // 等待线程结束

std::async - 用来异步执行函数,返回一个std::future对象。

1
2
3

auto result = std::async(foo); 
// do something else
result.get(); // 获取结果

std::mutex - 互斥量,用于保护共享数据的互斥访问。
std::lock_guard - 栈封装的锁,自动加锁和解锁。
std::promise/std::future - 提供设置和获取异步运算结果的机制。
std::condition_variable - 条件变量,用于线程等待和通知。

通过组合使用上述组件,可以方便地实现多线程程序,例如使用mutex保护共享数据,用condition_variable实现线程同步等。
整个线程库提供了较底层的线程控制功能,可以建立在OS原生线程之上,跨平台使用。

这里是一个使用std::promise和std::future的示例代码:

#include <future>
#include <iostream>

int do_work() {
  // 假设这里做了一些工作
  std::cout <<"do work " <<std::endl;
  return 123; 
}

int main() {

  std::promise<int> prom;
  std::future<int> fut = prom.get_future();

  std::thread t([&prom](){
    int result = do_work(); // 计算结果
    prom.set_value(result); // 设置 Promise 的结果
  });

  int result = fut.get(); // 从 Future 获取结果

  std::cout << "Result: " << result << std::endl;

  t.join();

  return 0;
}

编译和运行

编译
g++ -o thuse thuse.cpp -std=c++0x -lpthread

运行
do work
Result: 123

在这个例子中,我们在一个线程中进行实际的工作并计算结果。然后通过std::promise对象进行通信,将结果传递给std::future对象。
主线程通过future来获取结果。这样就实现了异步运算与结果获取。
std::promise/future提供了一个强大的多线程同步和通信机制,是C++11多线程编程中的重要工具。

容器增强:unordered_map等哈希表

下面是一个使用C++11中unordered_map的示例代码:

#include <unordered_map>
#include <iostream>

int main() {

  // 创建一个哈希表
  std::unordered_map<std::string, int> myMap;

  // 插入一些元素
  myMap["a"] = 1;
  myMap["b"] = 2;
  myMap["c"] = 3;

  // 查找元素
  std::cout << myMap["a"] << std::endl; // 输出1

  // 判断元素是否存在
  if (myMap.count("x") == 0) {
    std::cout << "x not found" << std::endl; 
  }

  // 遍历所有的键值对
  for (auto& x: myMap) {
    std::cout << x.first << ": " << x.second << std::endl;
  }

  return 0;
}

编译与输出：

编译
g++ -o unmap unmap.cpp --std=c++0x

输出
1
x not found
c: 3
b: 2
a: 1

unordered_map是一个无序的哈希表,它可以快速进行插入、删除和查找操作。
它常用于如下场景:

需要快速判断某个键是否存在时,可以使用unordered_map的count()方法判断,效率很高。
需要快速根据键查找值时,unordered_map的[]操作符可以快速取得值。
需要构建键值映射关系时,unordered_map的键值对存储方式非常适合构建映射表。
需要对数据进行计数统计时,可以将值作为计数器,利用unordered_map快速增减计数。
需要对大量数据进行去重时,可以将元素作为键放入unordered_map,即可高效地进行去重。
需要高效地对元素进行分类时,可以将分类作为键,将元素放入map中进行分类统计。

总之,unordered_map是一个非常有用和高效的哈希表容器,在很多场景下都可以提供很好的性能。正确使用它可以大大优化程序的性能。

c++11有哪些容器增强了

C++11对标准库容器做了很多增强,主要新增和优化了以下几个方面:

无序容器:新增了unordered_map、unordered_set、unordered_multiset、unordered_multimap等无序哈希表容器,提供了基于哈希表的高效插入和查询。
移动语义:大多数容器现在支持移动语义,可以更高效地移动对象而非拷贝对象。
初始化列表:支持直接用初始化列表初始化容器,如std::vector v{1,2,3}。
容器遍历:新增范围for循环语法,可以简化容器遍历,如for(auto& x : v)。
容器操作:一些容器增加了空间预留、容器合并、拷贝操作等新方法。
容器性能:优化了很多标准容器的性能,如vector随机访问性能提升了。
智能指针:新增智能指针shared_ptr、unique_ptr等,可以安全地管理堆内存。
元组:新增tuple可以存储不同类型的元素。
数组:新增数组容器array等。
正则表达式:新增正则表达式库。

总之,C++11对标准库容器进行了全方位的增强和优化,使用新特性可以大大提高代码效率和质量。正确运用这些容器特性是编写高质量C++11代码的关键。

元组:std::tuple

std::tuple是C++11新增的一个模板类,它允许你存储不同类型的数据。

下面给出std::tuple的详细介绍:

定义Tuple
使用模板参数定义tuple,参数类型可以不同:

1	std::tuple<int, std::string, float> myTuple;

初始化Tuple
可以通过构造函数初始化tuple:

1	std::tuple<int, std::string, float> myTuple(1, "hello", 3.14f);

也可以通过make_tuple函数初始化:

1	auto myTuple = std::make_tuple(1, "hello", 3.14f);

访问Tuple元素
可以通过std::get来访问元素:

1
2
3

int x = std::get<0>(myTuple); // x = 1
std::string s = std::get<1>(myTuple); // s = "hello"
float f = std::get<2>(myTuple); // f = 3.14f

也可以用tie函数拆包Tuple:

1 2	int a; std::string b; float c; std::tie(a, b, c) = myTuple;

Tuple使用场景

返回多个值时,可以用Tuple打包返回,避免构造结构体。
需要把多个值组合成一个整体传递时,可以用Tuple组织。
同时遍历多个容器时,可以把多个容器打包为Tuple处理。
需要函数模板支持不同参数类型时,可以用Tupleuniform传入不同参数。

总之,Tuple是一个非常有用的工具类,可以方便地将多个值组合为一个整体。在C++编程中有很多用途。

长长整数类型long long

long long类型其实不是C++11新增的,它在之前的C++标准里就已经存在了。

具体来说,long long类型是在C++98标准里就引入的,用于支持比long更大的整数类型。后来也被C11所采用。

但是C++11标准对long long类型的支持做了增强和明确:

提供了ll或LL后缀表示long long常量
明确规定了long long的最小大小(不小于64bit)
提供了与long long相关的库函数,如std::llround等

所以可以说C++11标准增强和扩展了long long的功能,但并不是最初引入这个类型。

这里是一个使用C++11标准long long类型的简单示例

#include <iostream>

int main() {

  // 使用LL后缀表示long long
  long long big = 123456789123LL; 
  
  // 输出long long
  std::cout << big << std::endl;

  // 两个long long运算
  long long sum = big + 12345LL;
  
  // 输出结果
  std::cout << sum << std::endl;

  return 0;
}

编译和输出

编译
g++ -o longuse longuse.cpp --std=c++0x

输出
123456789123
123456801468

在C++11下,直接使用long long并以LL表示即可。
编译时需要加上-std=c++11参数,启用C++11支持。
当然,实际使用时需要注意long long可能溢出的范围限制。

对象构造增强:委托构造、继承构造

C++11中增加了两种对象构造的新机制:

委托构造(Delegating Constructor)
在一个构造函数中调用另一个构造函数,减少冗余代码。

class Foo {
  public:
    Foo(int a) {
      // ...
    }
    
    Foo(double b) : Foo(int(b)) { } // 委托其他构造函数
};

继承构造(Inheriting Constructor)
使用基类的构造函数初始化派生类。

struct Base {
  Base(int);
  Base(double);
};

struct Derived : Base {
  using Base::Base; // 继承所有基类构造函数
}

一个完整的示例代码：

#include <iostream>

class Base {
public:
  Base(int a) {
    std::cout << "Base(int) called a : " << a << std::endl;
  }
  
  Base(double b) : Base(int(b)){
    std::cout << "Base(double) called b : " << b << std::endl;
  }

  Base(double a, double b) {
    std::cout << "Base(double, double) called " << a << ", " << b << std::endl;
  }
};

class Derived : public Base {
public:
  using Base::Base; // 继承基类构造函数

  // 需要重定义某个构造函数
  Derived(double a, double b) : Base(a, b) {
    // do something
    std::cout << "Derived " << a << ", " << b << std::endl;
  } 
};

int main() {
  Derived d1(5); // 调用 Base(int)
  Derived d2(3.14); // 调用 Base(double)
  Derived d3(7.1 , 8.2); // 调用 Base(double, double)
  
  return 0;
}

编译及输出结果：

编译
g++ -o wei weituo.cpp --std=c++0x

输出
Base(int) called a : 5
Base(int) called a : 3
Base(double) called b : 3.14
Base(double, double) called 7.1, 8.2
Derived 7.1, 8.2

使用using就可以不用重新定义构造函数。
这两个特性可以简化对象构造代码,提高复用性。

委托构造减少重复逻辑,继承构造简化初始化。

内联命名空间

内联命名空间(inline namespace)是C++11新增的命名空间特性,其主要功能和使用方式如下:

内联命名空间的成员可以不需要命名空间限定就直接使用
同一编译单元内,内联命名空间等同于直接在外层命名空间声明

举个例子:

namespace A {
  inline namespace B {
    void func() {}
  } 
}

int main() {
  
  A::B::func(); // 不需要指定B空间

  A::func(); // B内联到A,可以直接这样调用

  return 0;
}

这使得内联命名空间B里的成员可以直接当做A空间的成员那样使用。

主要作用:

版本化,可以兼容旧代码
减少命名空间污染
提高可读性

内联命名空间需要同一编译单元内才生效。跨编译单元无法内联。
适当使用内联命名空间可以简化代码编写,改善命名空间使用体验。

内联命名空间必须要加inline关键字吗？
不必一定要使用inline关键字声明内联命名空间。

C++11在命名空间的声明中允许省略inline关键字:
也就是说下面两种声明是等价的:

namespace A {
  inline namespace B {
  }
}

namespace A {
  namespace B { // 隐式内联
  } 
}

所以inline关键字对于内联命名空间的行为没有实际影响,只是增加了语义描述,表示该命名空间为内联的。
编译器会将命名空间内的成员当作外层命名空间成员那样对待,这才是内联命名空间的实质。
所以inline关键字是可选的,不影响内联性质。但建议保留inline以提高代码可读性。

基于范围的for循环

基于范围的for循环(range-based for loop)是C++11新增的一种简化的遍历容器/数组的语法。

主要的形式是:

1
2
3

for (元素声明 : 容器) {
   //代码块
}

这会遍历容器中的每个元素,并自动获取元素。

相比传统的基于下标遍历,这种写法更简洁清晰。

例如遍历一个vector:

std::vector<int> vec = {1,2,3}; 

// 传统写法
for (int i = 0; i < vec.size(); i++) {
  int x = vec[i];
  // ...
}

// 基于范围的for循环  
for (int x : vec) {
  // 操作x
}

范围for循环可用于数组、容器等提供开始/结束迭代器的类型。
需要注意它只遍历,不能用于修改容器中的元素。

override和final关键字

override 和 final 是C++11新加入的两个非常有用的关键字,其含义和用法如下:

override:

用于函数后,表示该函数覆盖(重写)了基类的虚函数
会检查基类是否存在此虚函数,避免重载错写成重写

例如:

struct Base {
  virtual void foo();
};

struct Derived : Base {
  void foo() override; // 重写Base::foo
};

final:

用于类后,表示该类不能被继承,防止继续扩展
用于函数后,表示该函数是最后的覆盖版本,禁止子类重写

final关键字在C++中可以用于类和函数,主要使用场景有:

防止类被继承时,将类声明为final。

class Base final {
  //...
};

class Derived : Base // 错误,Base不能被继承

防止基类虚函数被override时,将虚函数声明为final。

class Base {
  virtual void foo() final; 
};

class Derived : Base {
  void foo(); // 错误,foo不能被重写
};

将一个重写的虚函数声明为final版本。

1
2
3

class Derived : Base {
  virtual void foo() final; // foo的最终重写版本 
};

所以当不希望类再被继承,或者一个虚函数重写到最后不希望继续override时,可以使用final关键字进行控制。
这提高了程序的稳定性和安全性。final带来限制的同时,也明确了设计意图。

override和final为继承与重写提供了更严格的控制,使多态性更加可靠。良好使用可以增强程序稳定性。

右值引用和移动语义

右值引用和移动语义是C++11新增的两个重要特性,可以更高效地转移资源。

右值引用

右值引用:

使用&&语法,允许绑定到临时对象和将要销毁的对象
使临时对象可以直接传入函数内部而不需要复制

void process(vector<int>&& v) {
  // 直接使用v
}

process(vector<int>{1,2,3}); // 临时对象作为右值传入

转移语义和交换函数
右值引用实现移动语义,避免复制开销

std::swap(T& a, T& b) {
  T tmp = std::move(a);
  a = std::move(b);
  b = std::move(tmp);
}

转发函数参数
通过模板参数转发,保留参数左右值属性:

template <typename T>
void foo(T&& t) {
  func(std::forward<T>(t)); 
}

完美转发
配合std::forward可以实现完美转发:

template <typename T>
void wrapper(T&& arg) {
  foo(std::forward<T>(arg));
}

右值引用返回值优化
函数返回右值引用避免复制:

Matrix&& factory() { 
  Matrix m;
  return std::move(m);
}

这些都是右值引用的典型应用场景,可以提高性能和效率。

移动语义

移动语义:

通过重载移动构造函数和移动赋值运算符实现
将右值对象的资源直接转移,避免深拷贝

class String {
public:
  String(String&& str) {
    // move resources from str
  }
  
  String& operator=(String&& str) { 
    // move resources from str
  } 
};

移动构造函数
直接将右值对象资源转移过来,避免深拷贝:

class String {
public:
  String(String&& str) : data(str.data) {
    str.data = nullptr; 
  }
};

移动赋值运算符
释放左边资源,直接转移右边资源:

class String {
public:
  String& operator=(String&& str) {
    if (this != &str) {
      free(data);
      data = str.data;
      str.data = nullptr;
    }
    return *this;
  }
};

对容器使用std::move
强制使用移动语义插入容器:
1
2
std::vector<String> v;
v.push_back(std::move(s));
对返回值使用std::move
让返回值成为右值:
1
2
3
4
String foo() {
String s;
return std::move(s);
}
移动语义可以大幅优化资源管理,减少拷贝和内存分配,提高效率。

右值引用让临时对象可以高效利用,移动语义转移对象所有权,减少复制开销。

Modern C++中会广泛使用它们实现性能优化。

展开全文 >>

阿里云Redis宕机事件复盘

2023-06-10

阿里云Redis宕机事件 (2019年) 复盘

事件

2019年4月12日,阿里云Redis服务在华东1区主availability zone发生故障,导致50%以上的Redis节点不可用,大量基于Redis的应用程序和网站不可访问。
造成此次故障的主要原因是自动化系统错误地将宕机的Redis节点标记为删除,这些节点上的子节点也被错误删除,最终演变成失控状态。

事件详情如下

1.事件起因

阿里云Redis服务一个自动化系统疏忽地将一些宕机节点标记为”要删除”状态。这些节点上的子节点也被错误地标记为删除。

2.事件蔓延

受影响节点上的客户端服务开始报连接超时和连接拒绝错误。 DELETE操作开始在主AZ的节点上递归执行,导致大量正常运行的Redis节点被错误删除。

3.事件检测

阿里云监控系统检测到主AZ的Redis节点数量突然大幅下降,用户报错率显著上升。判断这属于一次不正常事件,且有蔓延迹象。

4.事件响应

阿里云Redis团队立即关闭相关automated系统,制止DELETE操作的进一步执行。并手工恢复部分已删除但数据尚未覆盖的Redis节点。同时增加其他AZ的Redis节点数量,租户流量开始分流至其他可用区。

5.事件根因分析

经分析,造成此次事件的主要根因是:
（1） Automated系统的DELETE操作规则过于宽松,导致出现误删除正常节点的情况。
（2）自动化运维流程缺乏人工确认机制,完全依赖算法判断,增加了误判率。
（3）节点之间的CASCADE删除规则,使得个别节点的错误删除可以连锁反应,最终导致大面积节点Down。

后续整改

阿里云Redis团队修改automated系统的DELETE判断规则,增加人工确认机制。
优化节点删除流程,避免CASCADE效应。
增加业务监控,提高故障检测速度。持续推进机器人与人工协作,提高automated运维的准确性。

总结

这个事件反映出,作为一款基础服务,Redis的高可用性至关重要。阿里云Redis团队从事件中汲取教训,进行了很好的整改与优化。作为用户,我们也应考虑Redis这类基础服务的容灾能力,避免产生单点故障,影响业务连锁反应。

展开全文 >>

谷歌云SQL服务故障宕机事件复盘

2023-06-10

谷歌云SQL服务故障(2019年)

事件

2019年6月2日,谷歌云SQL服务发生了一次大规模故障,导致客户无法连接数据库实例达4个小时之久。这是谷歌云SQL服务启动以来影响最大的一次故障。

故障的起因是谷歌云SQL的认证服务出现了问题,导致所有新连接请求无法得到验证,进而无法连接数据库。

谷歌云的工程团队花了4个小时才完全恢复服务,首先临时禁用了认证要求以恢复所有连接,然后修复认证系统本身的错误。

复盘

这次故障暴露出谷歌云SQL存在一些设计缺陷和单点故障问题:

依赖统一的认证系统,出现问题会影响所有用户。没有设计冗余机制。
修复故障花费时间过长,4个小时的服务中断对许多客户来说是不可接受的。
临时禁用认证机制以恢复服务也是一个安全隐患,可能被有心人利用。
事后通知客户的速度太慢,许多客户在社交媒体上表达了强烈的不满。

改进措施

这次故障给谷歌云和用户都上了一课。谷歌云后来推出了多项改进措施:

重构认证系统,采用更加故障隔离和冗余的架构。
建立更快速的故障检测与修复流程,明确重要服务的恢复时间目标。
加强对重要服务状态的监控,一旦发生故障能快速检测并通知相关技术团队。
建立清晰的客户通知机制,在故障发生后能及时通过多种渠道通知最大范围的客户。
提供服务赔偿并延长服务试用期等补偿机制,保留客户的信任。

总结

这次故障带来的 lesions 对云服务商来说极其宝贵,它检验了谷歌云SQL的工程实力与客户响应能力,最终促使其成为一款更加可靠与安全的服务。这也为其他云服务提供了极好的借鉴。
总之,通过这次故障可以看到成熟的云服务所面临的种种挑战,以及建设更加健壮服务所需要的种种措施与诚意。这是一个值得其他云服务商学习的案例。

展开全文 >>

struct与class的对比

2023-06-10

展开全文 >>

const引用过的变量是否可以被修改

2023-06-10

const引用过的变量是否可以被修改

修改const引用

对于C/C++中的const变量,通常不能直接修改其值。但是有些情况下,可以通过特定方式修改const变量的值:

1.通过casts去除const性质。

例如

1
2
3

cpp
const int x = 10;
(int&)x = 20;   // 通过cast去除const性质

这种方式编译器可能会发出警告,且破坏了const的语义,不推荐使用。

2.通过指针修改const变量。

例如:

cpp
const int x = 10;
int *ptr = (int*)&x;  // 通过cast获得指针
*ptr = 20;            // 通过指针修改值

这也破坏了const的语义,可能导致undefined behavior,不推荐。

3.如果const变量是类/结构体的成员,可以通过非const指针修改。

例如:

cpp
struct Foo {
    int x;
    const int y = 10;
};

Foo f;
Foo *p = &f;
p->y = 20;     // 合法,通过非const指针修改

这是因为通过指针访问成员时,const性质会被忽略。这也不推荐在设计中出现。

4.如果const变量有可变成员,可以通过该成员修改值。

例如:

cpp
struct Bar {
    mutable int x;      // 可变成员变量
    const int y = 10; 
};

Bar b;
b.x = 20;              // 合法,可变成员可以修改

这种情况下,通过可变成员的修改也会间接破坏const变量的值。所以设计时也需要避免。

总结

除上述几种情况外,const变量的值是不可以被直接修改的。所以在绝大多数情况下,我们可以认为const的值是不可变的。如果出现上述情况破坏const语义,这通常属于代码设计的缺陷,需要在设计时予以避免。

编码

#include <iostream>

void func1();
void func2();
void func3();

int main()
{
	func1();
	func2();
	func3();
	return 0;
}

void func1()
{
	std::cout << __FUNCTION__ << std::endl;
	const int x = 10;
	std::cout << "x: " << x << std::endl;
	(int&)x = 20;   // 通过cast去除const性质
	std::cout << "x: " << x << std::endl;
	std::cout << "(int&)x: " << (int&)x << std::endl;
}

void func2()
{
	std::cout << __FUNCTION__ << std::endl;
	const int x = 10;
	std::cout << "x: " << x << std::endl;
	int *ptr = (int*)&x;  // 通过cast获得指针
	*ptr = 20;            // 通过指针修改值 
	std::cout << "x: " << x << std::endl;
	std::cout << "ptr: " << *ptr << std::endl;
}

struct Foo {
    mutable int x;
    const int y = 10;
};

void func3()
{
	std::cout << __FUNCTION__ << std::endl;
	Foo f;
	Foo *p = &f;
	std::cout << "y: " << p->y << std::endl;
//	p->y = 20;     // 合法,通过非const指针修改
	std::cout << "p->y: " << p->y << std::endl;
	std::cout << "f.y: " << f.y << std::endl;
}

输出效果

func1
x: 10
x: 10
(int&)x: 20
func2
x: 10
x: 10
ptr: 20
func3
y: 10
p->y: 10
f.y: 10

展开全文 >>

月色与雪色之间

2023-05-27

月色与雪色之间

心灵猎手

李白。
李白的许多诗作都表达了强烈的情感和爱意,充满浪漫主义色彩。他擅用兴叹词和夸张手法来表达激情四溅的情感,是中国古典情诗的代表诗人。

辛弃疾。
辛弃疾的诗凄婉,代表作《青玉案·元夕》和《破阵子·如梦令》等,表现了哀伤离别和深深思念之情,是中国古典情诗的巅峰之作。

毛姆。
毛姆擅长写充满浪漫和生机的情诗,语言简洁流畅,富于音乐性。代表作《再会吧!再会吧!》和《我有一枝花》等,表达了对爱与春天的热爱之情。

雪莱。
雪莱的诗歌造词精巧,充满激情与浪漫主义色彩,代表作《西风颂》等,表达了深深的爱意与理想主义情怀,是英国浪漫主义诗歌的代表诗人。

拜伦。
拜伦的诗作气势磅礴,主题广博深刻,同时也有很多浪漫主义色彩的爱情诗篇,代表作《唐璜》和《哀歌》等,蕴涵深刻的思索与哀愁情绪。他是英国浪漫主义最重要的诗人之一。

雨果。
雨果的诗歌语言华丽而富有激情,代表作《你还记得我们在一起的日子》和《致利玛窦》等,表达了热烈浪漫的爱意与理想,是法国浪漫主义诗歌的代表诗人。

一锅鸡汤

“两千年前的人和现代人一样,都必须面临人生的三件难事:生老病死。”
——泰戈尔

“当你在做一件事的时候,尽量做好;当你没有在做事的时候,多观察和学习。”
——莎士比亚

“生活虽然艰难,但最可怕的不是滑倒,而是不再爬起。”
——席勒

“人生没有彩排,每天都是实况直播,所以我们要学会在行走中成长。”
——安迪·安德鲁斯

“智者不惧生,愚者不惧死;死亦生,生亦死。”
——老子

“沉默是一项巨大的能力。沉默会让我们倾听内心的声音,这些声音常常会带来惊人的启示。”
——马丁·路德·金

“你为什么要纠缺我呢?你不如检讨一下自己。”
——鲁迅

“最难得的是生命之体验,最可贵的是生命之启示。”
——泰戈尔

“人生最痛苦的不是失败,而是我们没有勇敢地去尝试。”
——罗马尼亚作家米哈伊尔·萨达勒

“生命已经给了我们这么多,我们还在索取什么呢?”
——聂鲁达

展开全文 >>

悬挂引用

2023-05-27

悬挂引用

问题：const std::string& 传入的如果是一个局部变量给一个全局变量会怎么样

如果将一个局部变量的const std::string &传递给一个全局变量,会发生什么?
这属于悬挂引用(dangling reference)的情况。
当局部变量离开作用域后,其内存会被释放,而全局变量仍持有这个引用,导致访问无效内存,这是非常危险的。

举例

例如:

cpp
void foo() {
    std::string str = "hello";
    const std::string &ref = str;
    global_ref = ref;  // 悬挂引用!
}

std::string global_ref;

int main() {
    foo();
    std::cout << global_ref;  // 未定义行为!原内存可能已被其他变量占用
}

在foo()函数中,str是一个局部变量,当foo()调用结束后,str所占用的内存会被释放。
但是全局变量global_ref却持有str的一个const引用,这会导致global_ref访问的内存不是原来的”hello”字符串,而是其他的无效内存。
这属于非常严重的程序缺陷,运行时行为是未定义的,可能产生致命错误。

正确的做法是不要传递局部变量的引用给全局范围,有几种解决方案:

1.不传递引用,传递实值的副本

cpp
void foo() {
    std::string str = "hello";
    global_ref = str;  // 传递实值副本
}

2.如果必须传递引用,传递堆上创建的字符串对象的引用

cpp 
void foo() {
    std::string *ptr = new std::string("hello");
    global_ref = *ptr;   // 传递堆对象引用
}

3.不将引用传递给全局域,只在局部域使用

cpp
void foo() {
    std::string str = "hello";
    const std::string &ref = str;
    use(ref);        // 在局部域使用引用 
}

void use(const std::string &ref) { ... }

总结

所以,总结来说,不要将局部变量的引用传递给全局域,这会产生悬挂引用导致未定义行为。
如果需要传递引用,只在局部域使用,或者传递堆上对象的引用。传递实值拷贝也是一种简单可靠的选择。
这样可以确保程序的正确性,避免产生悬挂引用等危险情况。

展开全文 >>

线程安全问题

C++中各种类型的线程安全问题

解决线程安全问题的多种方案

互斥量(Mutex)

信号量(Semaphore)

原子操作(Atomic)

线程同步(Synchronization)

std::condition_variable::notify_one()是什么

unique_lock/lock_guard 上锁 是什么

C++进阶问题整理

什么是RAII原则？它有什么作用？

什么是RTTI信息？

构造函数和析构函数的执行顺序是什么?

虚继承对构造和析构的影响

C++类成员在内存中是怎样存储的?

c++普通函数、局部变量、全局变量在内存中怎么存储

存储位置和生命周期的关系c++

什么是内存泄漏和野指针?如何避免?

什么是右值？

std::vector的push_back和emplace_back比较

c++基础问题整理

背景

什么是多态？如何实现多态？

什么是虚函数？为什么要使用虚函数？

虚函数的实现原理？

什么是虚函数表？

什么是继承？继承有哪些特性？

派生类可以访问基类的public, protected, private成员吗？

继承类型对派生类的影响是什么？这三种继承类型的区别是什么？

派生类可以作为基类的友元函数调用

友元函数

如果在class定义中没有显式指定访问权限,则默认为private

什么是抽象类和接口？它们之间有什么区别？

抽象类示例

子类在继承抽象类时,必须实现抽象类中的所有纯虚函数,否则子类也变为抽象类

接口示例

重载与重写

重写虚函数的时候该不该加override?

C++中的静态绑定和动态绑定

什么是内联函数?内联函数和宏的区别是什么?

C++中虚析构函数的作用及需要场景

虚基类

虚基类和虚继承的关系？什么情况下用虚基类？

例如类A,B都虚继承自Base,C继承A,B, 那么ABC共享一份Base数据吗？

C++11重要的新特性

自动类型推导:auto、decltype

统一初始化语法:{}

Lambda表达式和函数对象包装器(如std::function)

强类型枚举类enum class

nullptr和强制类型转换操作

nullptr

强制类型转换

标准线程库

容器增强:unordered_map等哈希表

c++11有哪些容器增强了

元组:std::tuple

长长整数类型long long

对象构造增强:委托构造、继承构造

内联命名空间

基于范围的for循环

override和final关键字

右值引用和移动语义

右值引用

移动语义

阿里云Redis宕机事件 (2019年) 复盘

事件

事件详情如下

1.事件起因

2.事件蔓延

3.事件检测

4.事件响应

5.事件根因分析

后续整改

总结

谷歌云SQL服务故障(2019年)

事件

复盘

改进措施

总结

const引用过的变量是否可以被修改

unique_lock/lock_guard 上锁是什么