C++工程 - 分类 - 星河拾贝录

使用LLVM的libFuzzer进行fuzzy test

Tue, 23 May 2023 00:00:00 +0000

libFuzzer 简介

LLVM libFuzzer 是 LLVM 生态系统中的一个fuzzy test工具，用于自动化地发现软件程序中的漏洞和错误。它通过生成大量的随机输入数据并观察程序的行为来进行fuzzy test。 libFuzzer 是一个基于内存的fuzzy test引擎，使用 LLVM 的插桩技术和代码优化功能来提高测试效率和覆盖率。

以下是 libFuzzer 的一些功能特点：

自动化fuzzy test：libFuzzer 提供了一种自动化的fuzzy test方法，可以生成大量的随机输入数据，并在每个输入上运行目标函数进行测试。它通过观察程序的崩溃、断言失败、未定义行为等反馈来发现潜在的问题。
内存安全性：libFuzzer 通过使用 AddressSanitizer (ASan) 和 UndefinedBehaviorSanitizer (UBSan) 等工具来确保fuzzy test过程中的内存安全性。这有助于检测和报告内存错误、缓冲区溢出、使用已释放内存等问题。
代码覆盖率分析：libFuzzer 使用 LLVM 提供的代码覆盖率分析技术，帮助确定已经执行过的代码路径和未执行的代码区域。这有助于评估测试的质量和覆盖范围，并帮助发现潜在的漏洞。
快速收敛：libFuzzer 使用一种称为 “回退”（Backoff）的策略，以更快地收敛到程序中的漏洞。它会根据测试结果调整输入数据的变异程度，使得能够更快地发现问题并生成更有潜力的测试用例。
灵活性和可定制性：libFuzzer 提供了多种选项和配置参数，使用户能够根据自己的需求进行定制。例如，可以设置最大测试时间、内存消耗限制、覆盖率报告等。
多线程支持：libFuzzer 支持多线程执行，可以利用多核处理器并行进行fuzzy test，加快测试速度。

示例

下面是一个使用 libFuzzer 的简单示例

首先我们有一个 test_fuzzy.cpp:

#include 
#include 

void DoSomethingWithData(const uint8_t* data, std::size_t size) {
  int* p = nullptr;
  if (size < 10) return;
  if (data[0] == 'h' && data[1] == 'e' && data[2] == 'l' && data[3] == 'l' && data[4] == '0') {
    *p = 42;
  }
  return;
}

extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, std::size_t size) {
  DoSomethingWithData(data, size);
  return 0;
}

使用 clang++进行编译：

为什么c++中有了函数指针却还需要std::function

Wed, 28 Sep 2022 00:00:00 +0000

在C/C++中，我们经常会像下面的代码那样使用一个指向函数的指针，我们称之为函数指针：

// demo.c
#include 

int func(int a) {
    return a + 1;
}

int main(int argc, char* argv[]) {
    int (*f)(int) = func;
    printf("%p\n", f);
    return 0;
}

上面的例子中，我们定义了一个函数func，然后通过函数指针f指向func，接着使用print函数打印指针变量f指向的地址。代码平淡无奇，接着我们编译代码，然后使用objdump -D demo来查看生成的二进制结构如下：

使用std::list的splice方法实现LRU Cache

Sun, 15 May 2022 00:00:00 +0000

std::list splice 简介

splice函数通过重新排列链表指针，将一个std::list中的节点转移到另一个std::list中。在元素的转移过程中不会触发元素的拷贝或者移动。因此，调用splice函数之后，元素现有的引用和迭代器都不会失效。

下面是一个将listA中所有节点附加到listB的一个简单代码示例，转移的过程不会导致listA中元素的引用和迭代器失效:

// Note: c++17 required below. (For CTAD(Class template argument deducation))
std::list listA{1, 2, 3};
std::list listB{4, 5, 6};

auto it = listA.begin();   // Iterator to 1

// Append listA to listB
listB.splice(listB.end(), listA);

// All listA elements transferred to listB
std::cout << listB.size() << " " << listA.size() << std::endl;   // 6 0

// Prints Below: 4 5 6 1 2 3
for (auto i : listB) {
    std::cout << i << " ";
}
std::cout << std::endl;

// Iterator still valid
std::cout << *it << std::endl;   // 1

当然，我们也可以在不使用splice的情况下将一个 list 中的元素转移到另一个 list 中，但是需要将原 list 中的元素删除，并在目标 list 中插入新的元素。删除和新增元素对于较小的对象（例如 int）是可以接受的，但是对于较大的对象来说，由于需要调用拷贝/移动构造和析构函数，所以成本会很高。

深入理解 enable_shared_from_this

Tue, 03 May 2022 00:00:00 +0000

关于 shared_ptr

shared_ptr是一种共享所有权的智能指针，它允许我们安全地访问和管理对象的生命周期。shared_ptr的多个实例通过共享控制块结构来控制对象的生命周期。控制块维护了引用计数(reference count)，弱引用计数(weak count)和其他必要的信息，通过这些信息，控制块能够确定一个对象在内存中是否可以被安全销毁。

当使用原始指针构造或者初始化一个shared_ptr时，将会创建一个新的控制块。为了确保一个对象仅由一个共享的控制块管理，必须通过复制已存在的shared_ptr对象来创建一个新的shared_ptr实例，例如：

void good()
{
  auto p{new int(10)}; // p is int*
  // create additional shared_ptr from an existing shared_ptr
  std::shared_ptr<int> sp1{p};
  // sp2 shares control block with sp1
  auto sp2{sp1};
}

而使用指向已由shared_ptr管理的对象的原始指针来初始化另一个shared_ptr时，会创建一个新的控制块来管理该对象，这样同一个对象就同时被多个控制块管理，这会导致 undefined behavior，例如：

c++ 中 unique_ptr 的一些使用技巧

Wed, 20 Apr 2022 00:00:00 +0000

前言

c++11 对智能指针做了很大的优化，废弃了 c++98 中的auto_ptr，引入了三种新的智能指针：unique_ptr，shared_ptr，weak_ptr。本文将针对unique_ptr的一些使用技巧做一些整理和归纳。在正式开始之前，我们首先来回顾一下unique_ptr的特点：一个unique_ptr对象内包含一个原始指针，该unique_ptr对象负责管理原始指针的生命周期。一个unique_ptr对象始终是其关联的原始指针的唯一拥有者。

在了解了unique_ptr的特点之后，我们来具体看看日常开发中unique_ptr的一些使用场景和技巧。

一些场景

本地对象指针

在开发中，我们经常会遇到或者写出类似于下面这样的逻辑：

void somefunc() {
    Object obj = new Object;
    // ...
    if (/* event 1 */) {
        delete obj;
        return;
    }

    if (/* event 2 */) {
        delete obj;
        return;
    }
    delete obj;
}

对于这样的代码，写起来很麻烦，看上去也及其丑陋。以前我们常用的一种优化手段就是使用goto，而在 c++11 之后，我们有了一种更加优雅简洁的方式，来对上面的代码进行优化，那就是使用unique_ptr:

Expression Templates

Wed, 06 Apr 2022 00:00:00 +0000

什么是 Expression Templates

Expression Templates 是一种 C++ 模板元编程技术，它通过在编译时构建按需执行的计算表达式，从而生成高效的代码。简单来说，通过 Expression Templates，我们可以实现惰性求值和消除因为中间结果而创建的临时变量。

一个常规示例

我们构造了一个MyVector类，并且重载了MyVector的+和*操作符，实现两个MyVector中相同下标元素的+和*操作。对于这样的需求我们很容易写出形如下面代码的一个简单的实现：

#include 
#include 
#include 

template<typename T> class MyVector
{
public:
    MyVector(const std::size_t n)
        : vec_(n)
    {}
    MyVector(const std::size_t n, const T initvalues)
        : vec_(n, initvalues)
    {}

    std::size_t size() const { return vec_.size(); }

    T operator[](const std::size_t i) const
    {
        assert(i < size());
        return vec_[i];
    }

    T& operator[](const std::size_t i)
    {
        assert(i < size());
        return vec_[i];
    }

private:
    std::vector<T> vec_;
};

template<typename T> MyVector<T> operator+(const MyVector<T>& a, const MyVector<T>& b)
{
    assert(a.size() == b.size());
    MyVector<T> result(a.size());
    for (std::size_t i = 0; i < a.size(); ++i) {
        result[i] = a[i] + b[i];
    }
    return result;
}

template<typename T> MyVector<T> operator*(const MyVector<T>& a, const MyVector<T>& b)
{
    assert(a.size() == b.size());
    MyVector<T> result(a.size());
    for (std::size_t i = 0; i < a.size(); ++i) {
        result[i] = a[i] * b[i];
    }
    return result;
}

template<typename T> std::ostream& operator<<(std::ostream& os, const MyVector<T>& vec)
{
    std::cout << '\n';
    for (std::size_t i = 0; i < vec.size(); ++i) {
        os << vec[i] << ' ';
    }
    os << '\n';
    return os;
}

int main(int argc, char* argv[])
{
    MyVector<double> x(10, 5.4);
    MyVector<double> y(10, 10.3);
    auto             ret = x + x + y * y;
    std::cout << ret << std::endl;
    return 0;
}

这个实现平淡无奇，相信每个人都能随手写出来。在godbolt上编译成汇编来分析：

c++中的动态多态和静态多态

Wed, 23 Mar 2022 00:00:00 +0000

动态多态 (Dynamic Polymorphism)

在 c++中为了实现多态，使用了一种动态绑定的技术，这个技术的核心就是虚函数表(virtual table)。下面就简单的说明一下基于虚表的动态绑定的原理，从而更好的与静态多态做比较。

在 c++中，每个包含虚函数的类都有一个虚表。我们来看下面这个类：

// demo.cpp
class A
{
public:
    virtual void vfunc1();
    virtual void vfunc2();
    void         func1();
    void         func2();

private:
    int m_data1, m_data2;
};

我们可以借助编译器来查看上述类的对象布局：

c++17:constexpr if

Fri, 18 Mar 2022 00:00:00 +0000

constexpr 是 c++11 引入的关键字，用于编译时常量和常量表达式。而 c++17 将这一特性做了增强，引入了 constexpr if ，使得编译器在编译时(compile time)能够做分支判断，从而有条件的编译代码。

下面可以通过一个简单的例子来看看constexpr if的用法：

#include 
#include 

template<typename T> auto getValue(T t)
{
    if constexpr (std::is_pointer<T>::value) {
        return *t;
    } else {
        return t;
    }
}

int main(int argc, char* argv[])
{
    int  a = 10;
    int* b = &a;
    getValue(a);
    getValue(b);
    return 0;
}

其实和普通的条件判断区别不大，只不过constexpr if中的条件是常量表达式，可以在编译时确定条件表达式的结果，从而选择编译对应的分支代码。我们可以将上述代码编译成汇编来进一步分析：

c++20:Designated Initializers

Tue, 15 Mar 2022 00:00:00 +0000

对于熟悉 c99 的人来说，Designated Initializers 并不算是什么新鲜事物，然而 c++直到 c++20 才正式支持这一特性。虽然在 c++20 之前，像 GCC 这样的编译器通过扩展的形式已经对该特性做了支持，但是随着 c++20 将其纳入新标准，这一特性将在所有编译器中得到支持。

基本用法

Designated Initialization 是聚合初始化(Aggregate Initialization)的一种形式。在 c++20 中，聚合类型(Aggregate types)是指：

数组类型
具备如下特性的 class 类型：
- has no private or protected direct non-static data members
- has no user-declared or inherited constructors
- has no virtual, private, or protected base classes
- has no virtual member functions

c++20 中的 Designated Initializers 的用法跟 c99 非常相似：

struct Points
{
    double x{0.0};
    double y{0.0};
};

const Points p{.x = 1.1, .y = 2.2};
const Points o{.x{1.1}, .y{2.2}};
const Points x{.x = 1.1, .y{2.2}};

优点

使用 Designated Initializers 最大的好处就是能够提升代码的可读性。

c++元编程之遍历tuple

Tue, 22 Feb 2022 00:00:00 +0000

对于一个标准的 c++容器来说，我们可以很容易在运行时使用迭代器和 range-based for loop 来遍历其中的每一个元素。但是对于std::tuple，却不能像普通的容器那样去遍历它。

std::tuple 简介

std::tuple是一个具有固定大小，包含不同类型值的集和。与之相似的是std::pair，只不过std::pair只能容纳两个元素，而std::tuple可以容纳许多元素：

std::tuple<int, double, const char*> tup {42, 10.5, "hello"};

// or with CTAD(class template argument deduction), C++17:
std::tuple deducedTup {42, 10.5, "hello"}; // 自动推导类型

访问std::pair中的元素只需要访问.first和.second成员即可: