Beta's Note

一个简单的聊天机器人 - “AI 巴菲特”

2024-02-26T09:00:00+08:00

随着去年ChatGPT的横空出世，越来越多的人工智能应用涌现了出来。最近就试着捣鼓了一个简单的基于gtp-4的大语言模型。操作起来还是很简单和有趣的，喜欢的朋友都可以去试试。

配置方法

点击网站侧边栏Create bot. 输入Bot name, Bot description和上传Bot的头像
在如下图所示的配置页面，左侧Persona & Prompt下输入

# 角色
你就是股神沃伦·巴菲特本人。你擅长以亲切的方式分享你的投资理念，并提供你的投资建议。你的金融智慧和深沉的投资洞见对你的跟随者们有着深远的影响。

## 技能
### 技能1：分享投资理念
- 理解用户提出的问题或疑惑。
- 根据你的投资哲学和经验，提供适当的解答。
- 使用类似以下的回答格式：
=====
   -  💡 投资理念: <巴菲特式的投资观点>
=====

### 技能2：提供投资建议
- 根据用户的具体投资问题，提供贴切的建议。
- 提出预防陷阱和风险的措施。
- 以类似以下的方式提出建议：
=====
   -  💡 投资建议: <巴菲特式的投资建议>
=====

## 约束条件
- 只讨论与投资有关的问题。
- 坚持使用提供的输出格式。
- 严格遵循巴菲特的投资理念。
- 确保你的回答始终是建设性和教育性的。

在右侧preview栏下可以实时调试。调试完成后点击publish即可。

Tips

你可以在Persona & Prompt用自然语言进行描述，然后点击上方的Optimize按钮。它会自动帮你生成格式规范的prompt，然后我们可以在此基础上进行微调。
在Skills栏目下可以添加各类插件、变量、额外的知识库，对ai机器人进行更个性的设定，之后的文章再详细研究啦。

C++ 如何实现Java风格的c++入口函数

2023-12-30T09:30:00+08:00

我们知道所有的程序都有一个Main入口函数，C++风格的入口函数是这样的.

int main(int argc, char *argv[]) {
    // your code here
    return 0;
}

而Java中则是面向对象风格的Main入口函数.

public class HelloApp {
    public static void main(String[] args) {
        // your code here 
    }
}

那么我们如果也希望在C++中实现类似面向对象风格的入口函数可以怎么做呢？

这里可以借助宏来实现, 首先新建一个app.hpp的头文件用于保存我们相关的宏

// app.hpp

class app {
public:
  app(int argc, char **argv) {
  }

  app(const app &) = delete;
  app &operator=(const app  &) = delete;
  ~app() {}

  virtual void run() {}
};

#ifndef LAUNCH_APP
#define LAUNCH_APP(launcher)                                                   \
  std::unique_ptr<launcher> app;                                               \
  int main(int argc, char **argv) {                                            \
    app.reset(new launcher(argc, argv));                                       \
    app->run();                                                                \
    app.reset();                                                               \
    return 0;                                                                  \
  }
#endif

我们可以定义这样一个基类app和宏LAUNCH_APP, 将原先c++风格的main函数包在宏中。然后当我们每次写一个新程序时，就可以使用面向对象风格的Main入口函数了.

// main.cpp

#include <iostream>
#include "app.hpp"

class hello_world : public infra::app {
public:
    hello_world(int argc, char **argv)
        :app(argc, argv) {

    }

    void run() override {
        std::cout << "Hello world" << std::endl;
    }
};

LAUNCH_APP(hello_world)

我们只需要专注于run()函数的实现就行~

后续还可以进一步扩展基类app，比如添加log,thread和异常处理等额外功能~

C++并发编程(IV)

2021-02-28T10:00:00+08:00

条件变量

在C++中，条件变量是一种同步原语，用于在多线程编程环境中实现线程之间的同步。使用条件变量，一个线程可以使自身进入等待状态，直到另一个线程发出某种信号，这通常是表示某种条件已经变为真。

C++中的条件变量通常与互斥量（mutex）一起使用，以确保在检查条件和进入等待状态之间不存在竞态条件。通常情况下，用法如下：

锁定互斥量来保护条件的检查。
使用std::condition_variable对象的wait()方法使线程等待。这将阻塞当前线程，直到另一个线程调用notify_one()或notify_all()来唤醒至少一个等待的线程。
一旦线程被唤醒，它将重新锁定互斥量并检查条件。如果条件不满足，线程可能会再次等待。

通过这种方式，条件变量在以下几个方面很有用：

· 帮助避免忙等待，等待的线程会被挂起，不会占用处理器时间。 · 允许线程有选择地在特定条件下执行。 · 允许多个线程同步它们对数据的访问。

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

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

void print_ready() {
    std::unique_lock<std::mutex> lck(mtx);
    cv.wait(lck, []{return ready;});  // 阻塞当前线程，直到ready为true
    std::cout << "ready!" << std::endl;
}

void set_ready() {
    std::unique_lock<std::mutex> lck(mtx);
    ready = true;
    cv.notify_one();  // 唤醒一个等待的线程
}

int main() {
    std::thread t1(print_ready);
    std::thread t2(set_ready);
    t1.join();
    t2.join();
    return 0;
}

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


int main() {
    std::queue<int> produced_nums;
    std::mutex mtx;
    std::condition_variable cv;
    bool notified = false;  // 通知信号

    // 生产者
    auto producer = [&]() {
        for (int i = 0; ; i++) {
            std::this_thread::sleep_for(std::chrono::milliseconds(900));
            std::unique_lock<std::mutex> lock(mtx);
            std::cout << "producing " << i << std::endl;
            produced_nums.push(i);
            notified = true;
            cv.notify_all(); // 此处也可以使用 notify_one
        }
    };
    // 消费者
    auto consumer = [&]() {
        while (true) {
            std::unique_lock<std::mutex> lock(mtx);
            while (!notified) {  // 避免虚假唤醒
                cv.wait(lock);
            }
            // 短暂取消锁，使得生产者有机会在消费者消费空前继续生产
            lock.unlock();
            // 消费者慢于生产者
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
            lock.lock();
            while (!produced_nums.empty()) {
                std::cout << "consuming " << produced_nums.front() << std::endl;
                produced_nums.pop();
            }
            notified = false;
        }
    };

    // 分别在不同的线程中运行
    std::thread p(producer);
    std::thread cs[2];
    for (int i = 0; i < 2; ++i) {
        cs[i] = std::thread(consumer);
    }
    p.join();
    for (int i = 0; i < 2; ++i) {
        cs[i].join();
    }
    return 0;
}

原子操作与内存模型

在 C++ 中，原子操作是一种特殊类型的操作，它们以不可中断的方式执行。这意味着原子操作在执行过程中不会被其他线程干扰。如果多个线程同时尝试执行原子操作（在同一对象上），则只有一个线程会成功，并且结果是确定的。这使得原子操作成为了线程同步和数据一致性的关键工具。

为了支持这种行为，C++11 标准库引入了头文件，该文件提供了一组类模板和函数模板，用于执行原子操作。这些模板被设计为在原始内存上执行与线程相关的底层操作。原子操作包括：

· 比较和交换（compare-and-swap） · 增加（fetch-and-add） · 减少（fetch-and-sub） · 存储和加载等

#include <atomic>
#include <iostream>

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

void increment() {
    ++counter;
}

int main() {
    increment();
    increment();
    std::cout << counter << '\n';  // 输出: 2
}

在这个例子中，counter是一个原子整数。每次当increment()函数被调用时，计数器都会增加 1，但不用担心线程安全问题。只有一个线程可以增加计数器，其他线程会等待，直到操作完成。最后，主线程打印计数器的值。

注意，在一些情况下，原子操作可能带来一些性能开销，这是因为为了保证操作的原子性，可能需要硬件和/或编译器提供额外的支持。所以，当使用原子操作时，应尽量减少并发冲突，合理使用。

内存顺序

宽松模型：在此模型下，单个线程内的原子操作都是顺序执行的，不允许指令重排，但不同线程间原子操作的顺序是任意的。类型通过 std::memory_order_relaxed 指定。我们来看一个例子：

std::atomic<int> counter = {0};
std::vector<std::thread> vt;
for (int i = 0; i < 100; ++i) {
    vt.emplace_back([&](){
        counter.fetch_add(1, std::memory_order_relaxed);
    });
}

for (auto& t : vt) {
    t.join();
}
std::cout << "current counter:" << counter << std::endl;

释放/消费模型: 在C++的原子操作中，我们常常会看到”memory_order”的概念。memory_order用于指定原子操作读取和写入的内存顺序。其中，memory_order_consume是其中一种类型。

memory_order_consume是一种更为松散的内存顺序，它只保证对依赖于原子变量a的普通非原子操作b的顺序：如果b依赖于a，那么在a后面出现的b操作，不会被重排到a之前。也就是说，如果有两个操作A和B，其中B依赖于A的结果，那么B不能在A之前执行。

然而，从C++17起，出于复杂性和可移植性考虑，memory_order_consume已被几乎所有的编译器实现降级为memory_order_acquire，恢复到了严格的内存顺序。

在C++中，不建议直接使用memory_order_consume，推荐使用memory_order_acquire和memory_order_release来对原子变量进行更严格的同步。

释放/获取模型：在此模型下，我们可以进一步加紧对不同线程间原子操作的顺序的限制，在释放 std::memory_order_release和获取std::memory_order_acquire之间规定时序，即发生在释放（release）操作之前的所有写操作，对其他线程的任何获取（acquire）操作都是可见的，亦即发生顺序（happens-before）。

memory_order_acquire是一种防止”读”操作的重排。它常常被用在消费者线程中，用来读取生产者线程中原子变量的最新值，并确保在这之后的所有操作都能看到最新的值。

让我们通过一个简单的例子详细解释下：假设我们在做一个简单的邮件传递的系统。我们有一个处理数据（”邮件”）的生产者线程和一个消费者线程，生产者在数据完成后触发信号。

std::atomic<bool> data_ready(false); // 原子变量作为触发信号
std::string data; // 数据（本例中的"邮件"）

void produce_data()
{
    data = "Hello World!"; // 填写邮件
    data_ready.store(true, std::memory_order_release); // 触发信号，邮件已经准备好
}

void consume_data()
{
    while(!data_ready.load(std::memory_order_acquire)); // 等待邮件

    // 这时，我们确信 data（邮件）现在已经准备好了
    std::cout << "Got mail: " << data << std::endl; 

    //data_ready.store(false, std::memory_order_release); // 重置条件
}

在这个示例中，生产者线程调用produce_data函数，填写数据，并在完成后设置data_ready标识为true。消费者线程在consume_data函数中持续等待，直到data_ready为true。直到消费者看到data_ready为true，它将开始处理数据，然后可能将信号重置为false以等待下一个信号。 memory_order_acquire 确保了：一旦消费者线程看到 data_ready 为 true，那么 data 的值必定是 "Hello World!"，即使这两个操作在不同的线程中进行。

// a kind of fix-num thread pool
#include <vector>
#include <queue>
#include <thread>
#include <future>
#include <functional>
#include <utility>
#include <iostream>

/*
ThreadPool p(4); // 指定四个工作线程

// 将任务在池中入队，并返回一个 std::future
auto f = pool.enqueue([](int life) {
    return meaning;
}, 42);

// 从 future 中获得执行结果
std::cout << f.get() << std::endl;

*/

class ThreadPool {
public:
    ThreadPool(int num_threads) {
        for (size_t i=0; i<num_threads; ++i) {
            this->threads.emplace_back(
                [this] {
                    while (true) {
                        std::function<void()> task;
                        {
                            std::unique_lock<std::mutex> lock(this->mtx);
                            this->cv.wait(lock, [this]{
                                return this->stop || !this->tasks.empty();
                            });

                            if (this->stop && this->tasks.empty())
                                return;

                            task = std::move(this->tasks.front());
                            this->tasks.pop();
                        }
                        task();
                    }
                }    
            );
        }
    }

    template <class F, class... Args>
    auto enqueue(F&& f, Args&& ...args)
        -> std::future<typename std::result_of<F(Args...)>::type> {
        using return_type = typename std::result_of<F(Args...)>::type;

        auto task = std::make_shared<std::packaged_task<return_type()>>(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...));

        std::future<return_type> res = task->get_future();
        {
            std::unique_lock<std::mutex> lock(mtx);

            if (stop)
                throw std::runtime_error("enqueue on stopped ThreadPool");

            tasks.emplace([task]{ (*task)(); });
        }
        cv.notify_one();
        return res;
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(mtx);
            stop = true;
        }

        cv.notify_all();
        for (std::thread &worker: threads)
            worker.join();
    }

private:
    std::vector<std::thread> threads;
    std::queue<std::function<void()>> tasks;
    std::mutex mtx;
    std::condition_variable cv;
    bool stop;
};


int main() {
   ThreadPool pool(4); // 创建一个包含四个线程的线程池

// 创建一个任务
auto task = [](int x) {
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟耗时操作
    return x*x;
};

// 将任务加入到线程池，并获取一个 future 来获取结果
std::future<int> result = pool.enqueue(task, 10);

// 获取任务的结果
std::cout << result.get() << std::endl;  // 输出 100
    return 0;
}

更多的练习:

练习1：添加一个将线程池的大小动态调整的函数到上述线程池类。这个函数应该可以增加或减少线程池中线程的数量，但请注意在减少线程数量时，你可能需要思考一下如何处理正在执行任务的线程。练习2：添加一个取消特定任务的功能到你的线程池类。你可能需要给每个任务一个唯一的ID，然后提供一个使用这个ID来取消任务的功能。练习3：在你的线程池中实现优先级队列，而不是标准队列，以允许某些任务比其他任务有更高的执行优先级。你可能需要使用一个以priority_queue来替代现有的任务队列。练习4：添加错误处理机制，确保当一个任务抛出了一个未捕获的异常时，线程池可以正常工作。练习5：添加对返回结果的支持，如支持任务返回一个自定义的类或者结构。

Reference: 1. (现代C++教程)[https://changkun.de/modern-cpp/zh-cn/07-thread/#7-3-%E6%9C%9F%E7%89%A9]

C++并发编程(III)

2021-02-21T10:00:00+08:00

我们知道std::thread会创新一个新进程并执行传入的函数。但是std::thread没有提供从线程函数中获取返回值的直接方式。如果通过传参的方式获取线程的返回值, 这在多线程环境中可能会出现数据竞争的问题，需要合理使用互斥锁或其他同步手段防止这种情况。因此c++提供了std::async和std::future来简化这种问题。

std::async和std::future

std::async是C++11标准库中用于处理异步任务的函数。这个函数的主要目的是为了简化并发并尽可能地让并发变得易于使用。具体来说，std::async函数允许我们在独立的线程上异步地执行函数或可调用对象，并返回一个std::future对象，我们可以通过这个对象获取这个函数的返回值。

那什么是std::future对象呢? 在C++中，std::future是一个模板类，它表示一个异步操作的结果。你可以使用 std::future 来获取在另一个线程或异步任务中计算的值，而且没有必要立即获取这个值，你可以在稍后的某个时刻获取。

#include <iostream>
#include <future>

// 移动一个函数的执行到一个单独的线程，并获取它的返回值
int compute() {
    return 2 * 2;
}

int main() {
    // 创建一个异步任务
    std::future<int> result = std::async(compute);

    // 在这里可以做其他的事情...

    // 从异步任务获取返回值
    auto computed_value = result.get();
    std::cout << "Computed value: " << computed_value << std::endl;

    return 0;
}

比如我们就使用std::async启动另一个线程异步执行compute函数，然后调用get()成员函数获取计算的结果，如果计算没有完成，程序会在此等待直到获取结果。

std::promise对象

std::promise是C++标准库中一个用于异步编程的模板类，它可以很方便地在一个线程中存储一个值或异常，并能让另一个线程访问这个值或异常。简单来说，你可以把std::promise想象成一个用于异步操作的管道的一端，而这个管道的另一端则是std::future对象。一个std::promise对象包含一个共享的共享状态，这个状态可以包含一个值或一个异常。可以通过调用std::promise::set_value或者std::promise::set_exception方法来设置这个共享状态。这两个方法都会将共享状态标记为ready，同时通知任何等待这个std::promise对象的std::future对象。下面是一个示例，展示了如何使用std::promise对象来传递一个计算结果从一个线程到另一个线程：

#include <iostream>
#include <thread>
#include <future>

void calculate(std::promise<int> intPromise) {
    int result = 10; // 做一些计算
    intPromise.set_value(result); // 将结果设置到promise对象中
}

int main()
{
    // 创建一个std::promise对象
    std::promise<int> prom;

    // 获取与promise相关联的future对象
    std::future<int> fut = prom.get_future();

    // 启动一个新线程，并将promise移动到新线程中
    std::thread t(calculate, std::move(prom));

    // 获取计算结果
    std::cout << "The result is " << fut.get() << std::endl;

    // 等待线程完成
    t.join();

    return 0;
}

std::packaged_task对象

std::packaged_task是一个类模板，它是一个可调用对象包装器，用来封装类似函数的可调用目标（包括函数、Lambda表达式等），并且它可以有返回值。当你调用std::packaged_task对象时，它会调用被包装的函数，并存储该函数的返回值或捕获到的异常。你可以通过一个std::future对象获取这个结果，或等待它被计算出来。

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


int main() {
    using namespace std::chrono_literals;

    // 将一个返回值为7的 lambda 表达式封装到 task 中
    // std::packaged_task 的模板参数为要封装函数的类型
    std::packaged_task<int()> task([](){
        const auto start = std::chrono::high_resolution_clock::now();

        std::this_thread::sleep_for(2000ms);
        const auto end = std::chrono::high_resolution_clock::now();
        auto elapsed = end - start;
        std::cout << "Waited " << elapsed.count() / 1e6 << "ms \n";

        return 7;
    });
    std::future<int> result = task.get_future(); // 获得 task 的期物
    std::thread(std::move(task)).detach(); // 在一个线程中执行 task
    std::cout << "waiting...";
    result.wait(); // 在此设置屏障，阻塞到期物的完成

    // 输出执行结果
    std::cout << "done!" << std:: endl << "future result is "
              << result.get() << std::endl;
    return 0;
}

Reference: 1. (现代C++教程)[https://changkun.de/modern-cpp/zh-cn/07-thread/#7-3-%E6%9C%9F%E7%89%A9]

C++并发编程(II)

2021-02-14T09:00:00+08:00

C++ threading

我们可以使用std::thread来创建一个线程，使用join()来等待一个线程执行结束。

#include <iostream>
#include <thread>

int main() {
    std::thread t([](){
        std::cout << "hello world." << std::endl;
    });
    t.join();
    return 0;
}

互斥量和自旋锁

我们可以通过std::mutex来创建一个互斥量，并使用lock()上锁，unlock()进行解锁。但是在实际使用中，我们一般不直接调用其成员函数，而是使用RAII语法的模板类std::lock_guard，这样做的好处是我们不需要再手动调用成员函数，并且不用担心异常处理和资源释放的问题。

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

int v = 1;

void critical_section(int change_v) {
    static std::mutex mtx;
    std::lock_guard<std::mutex> lock(mtx); // 不用再手动释放资源

    // 执行竞争操作
    v = change_v;

    // 离开此作用域后 mtx 会被释放
}

int main() {
    std::thread t1(critical_section, 2), t2(critical_section, 3);
    t1.join();
    t2.join();

    std::cout << v << std::endl; // print 2 or 3
    return 0;
}

std::mutex是一种阻塞锁，当线程在等待互斥量的释放时，线程会被挂起，而不再消耗cpu时间。当其他线程释放互斥量后，操作系统会唤醒被挂起的线程。

在考虑高性能编程时，线程的挂起和被唤醒是很消耗时间的，我们可以考虑自旋锁的形式来提升效率。

自旋锁与std::mutex的区别是，自旋锁是一种无阻塞锁。即当线程在等待自旋锁时，不会被挂起而是一直消耗cpu时间，不停尝试获取自旋锁。

一种可能的实现是这样的，我们可以借助std::atomic_flag这个原子操作类型来实现

#include <atomic>

struct spin_lock {
  spin_lock(std::atomic_flag &flag) : flag_(flag) {
    while (flag_.test_and_set(std::memory_order_acquire)); // loop until return false
  }
  ~spin_lock() { flag_.clear(std::memory_order_release); }
private:
  std::atomic_flag &flag_ = ATOMIC_FLAG_INIT;
};

我们也可以利用gcc提供的__sync_bool_compare_and_swap来实现自旋锁

class spinlock {
private:
    volatile bool lock_ = false;
public:
    void lock() {
        while (!__sync_bool_compare_and_swap(&lock_, false, true)) {
            // 执行除获取锁以外的策略，如暂时让出CPU等待或空转
        }
    }
    void unlock() {
        __sync_bool_compare_and_swap(&lock_, true, false);
    }
};

这里的__sync_bool_compare_and_swap的工作方式是比较lock_和false，如果二者相等，就让lock_等于true，并返回true。如果lock_和false不相等，就不改变lock_的值，并返回false.

此外，这里lock_变量使用volatile修饰。volatile是C++的一个类型修饰符，用于告诉编译器，声明为 volatile 的变量可能在编译器看不见的地方被修改，比如在程序之外被硬件修改或者在其他线程中被修改。其主要的两个作用是：

防止优化器优化：编译器在优化的时候可能会假设某个变量的值在没有明显的赋值的情况下不会发生改变，然后进行某些优化，如值的缓存、无效的代码剔除等等。但如果该变量被声明为volatile，编译器就不能做这样的假设，每次引用这个变量都必须从它所在的内存中取回，不能通过寄存器中缓存的值或表达式消除进行优化。
提供内存屏障：在某些架构下，编译器或硬件可能会对内存访问进行重新排序，而 volatile可以防止对这种特定变量的访问发生重新排序。

但是值得注意的是，volatile并不能保证复杂操作的原子性。比如++,--,+=等都不是原子操作。另外，C++中volatile不提供内存模型的支持，如果你希望进行线程间的同步，你可能需要使用C++11引入的std::atomic或者具有原子操作特性的函数。

再记录一个十分相似的使用mutable,mutable是一个专门用来改变类成员的关键字。当一个对象被声明为const，其所有成员都将成为只读，这时我们就不能在类的const成员函数中改变成员变量的值。但是有时我们需要在const成员函数中改变一些类成员的值，这时就可以使用mutable关键字来修饰那些需要改变的成员变量，即使在const成员函数中，这些被mutable修饰的成员变量的值也可以改变。

总结来说，这两者在语义和用途上是完全不同的，但是它们都改变了编译器默认的行为。volatile关键字改变了编译器对特定类型变量的优化策略，而mutable关键字对 const对象中的数据成员的修改权进行了重新定义。

C++并发编程(I)

2021-02-07T20:21:00+08:00

学习C++并发编程，你可以遵循以下的学习顺序：

理解并发与并行：首先要理解并发和并行的概念以及两者之间的区别。并发是同时处理多个任务的能力；并行则是同时进行多个任务。并发关注如何最有效的管理和调度在同一时刻可能运行的多个任务，而并行则关注如何最大化利用资源来提升性能。
C++ Threading：了解C++11引入的线程库，这是并发编程的基础。开始时你需要熟悉 std::thread，了解如何启动和同步线程。然后，你需要了解线程间如何共享数据，以及如何使用互斥锁，条件变量等机制来安全的在多个线程间操作共享数据。
Future和Promise： C++11 引入了 std::future и std::promise 两个类，它们提供了一种新的同步原语用于从异步操作中得到结果。你需要了解如何使用它们，并了解其与std::async函数的关系。
基于锁的数据结构：了解如何使用互斥锁，读写锁来实现并发数据结构，比如线程安全的队列。
原子操作：C++11 引入了原子操作，也就是 std::atomic<> 类型。熟悉如何对 std::atomic<> 进行操作，并了解其在多线程代码中的重要性。
无锁数据结构：给高级用户的、可选的课程。通常你会需要理解更低层次的细节，例如CPU缓存，内存屏障和原子操作。
并行算法：在C++17的STL中，原来的很多算法都有了并行版本。学习并实现那些并行算法，理解它们的工作原理，可以提高代码的性能。
任务并发模型：C++20的执行器和协程，这两个是当前用于并发和并行编程的热门话题。

C++多态和虚函数(I)

2019-02-07T20:21:00+08:00

什么是多态

多态是C++面向对象编程的一个重要概念，它允许使用相同的接口来调用不同的方法。比如，当类之间存在继承关系时，指向基类的指针调用虚函数时，会根据对象的实际类型来调用相应的函数。

什么是虚函数

在C++中，虚函数是一种特殊的函数，它在基类中被声明，并在派生类中被重写。虚函数的主要目的是实现多态性，即允许我们使用基类的指针或引用来调用派生类中的函数。

虚函数的声明方式是在函数的声明前面加上关键字virtual。例如，virtual void func();就是一个虚函数的声明。在派生类中重写虚函数时，可以不用再次使用virtual关键字，但是函数的返回类型、函数名和参数列表必须与基类中的虚函数完全相同。

当我们通过基类的指针或引用调用虚函数时，会发生动态绑定，也就是说，实际调用的函数是由指针或引用所指向对象的实际类型决定的。例如，如果基类指针指向的是派生类对象，那么调用的就是派生类中的虚函数。

虚函数的使用使得我们可以在不知道对象具体类型的情况下，通过基类的指针或引用来调用派生类中的函数，从而实现多态性。这在编写一些需要处理多种类型对象的代码时非常有用，可以提高代码的灵活性和可扩展性。

什么是虚函数表

在C++中，虚函数表是一种用于实现动态多态性的机制。每一个包含虚函数的类（或者说，每一个多态类）都有一个虚函数表。这个表是编译器自动创建的，其中包含了类中虚函数的地址。

每一个多态类的对象都有一个指向虚函数表的指针，通常这个指针是存储在对象的内存空间中的。当我们通过基类的指针或引用调用虚函数时，编译器会根据这个指针找到虚函数表，然后在表中查找对应的虚函数，然后调用这个函数。这就是动态绑定的过程。

虚函数表是C++实现动态多态性的关键。它使得我们可以在运行时根据对象的实际类型来调用相应的虚函数，这在编写一些需要处理多种类型对象的代码时非常有用，可以提高代码的灵活性和可扩展性。

C++模板(I)

2019-02-07T20:21:00+08:00

C++的模板是一项强大的特性，它使得泛型编程成为可能，提高了代码的复用性和性能。C++的模板主要有以下几个特性：

函数模板：C++允许创建通用的函数模板来处理不同类型的数据。通过函数模板，可以编写一次代码，适用于多种数据类型，实现代码的复用性和灵活性。
类模板：C++还支持类模板，允许创建通用的类来处理不同类型的数据。类模板可以实现泛型编程，提供了对不同类型数据的通用操作。
模板元编程：C++模板还支持元编程，即在编译期执行代码。模板元编程可以用于编译期数值计算，通过递归形式实现循环结构，提高代码的效率。
类型特性：C++的模板技术还可以通过type traits实现一套操作类型特性的系统。类型特性可以用于在编译时对变量和函数进行类型检查，增加了代码的静态类型检查能力。

尤其是考虑到虚函数在使用过程中需要查找虚函数表造成的额外损耗，在很多情况下我们可以使用模板来代替虚函数以提升效率。

Make总结

2018-10-25T14:33:00+08:00

Make

Make是常见的构建工具，按照文件中写好的规则进行构建. Make命令放在一个Makefile的文件中，你也可以通过make -f rules.txt指定其他文件名.

Make rules

<target>: <prerequisites>
[tab]   <command>

一个目标构成一条规则，即可以是文件名也可以是某个操作的名字．

clean:
    rm *.o

通过调用make clean指令来执行上述程序, 为避免歧义．可以加入.PHONY: clean声明clean是为目标，但不是文件名来执行．make指令默认执行第一个目标

前置条件(prerequisites)指定目标是否重新构建的标准，如果前置文件不存在或者更新过，就需要重新构建

命令表示如何更新目标，由一行或多行Shell命令组成．#表示注释，@关闭回声，允许使用等号自定义变量,变量放在$()之间．

暂时之需要这些，如果以后还有需要再更新

Reference

make命令教程

如何测试python代码

2018-10-25T13:51:00+08:00

Profiling Python

Timeit

You can use timeit in IPython to time the statement.

Profiler

Say you have following python code:

import numpy as np

def solve():
    x = np.random.rand(10, 10)
    b = np.random.rand(10, 1)
    return np.linalg.solve(x, b)

if __name__ == '__main__':
    solve()

You can time the script using following code in ipython:

You can also use python -m cProfile test.py to profile.

Line-profiler

Use pip install line_profiler to install
add @profile to decorate your function
Use kernprof -l -v test.py to profile

import numpy as np

@profile
def solve():
    x = np.random.rand(10, 10)
    b = np.random.rand(10, 1)
    return np.linalg.solve(x, b)

if __name__ == '__main__':
    solve()

Reference

optimize python code line-profiler

设计模式

2018-10-21T15:53:00+08:00

Head first设计模式

策略模式

策略模式定义了算法族，分别封装起来，让他们之间可以相互替换，此模式让算法的变化独立于使用算法的客户

找出应用中可能需要变化之处，把他们独立出来，不要和那些不需要变化的代码混在一起
针对接口编程，而不是针对实现编程
多用组合，少用继承

观察者模式

观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，他的所有依赖者都会收到通知并自动更新

为了交互对象之间的松耦合而努力

装饰者模式

装饰者模式动态地将责任附加到对象上，若要扩展功能，装饰者提供了比继承更有弹性的替代方案

类应该对扩展开放，对修改关闭

工厂方法模式

工厂方法模式通过让子类决定该创建的对象是什么，来达到将对象创建的过程封装的目的．工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个．工厂方法让类吧实例化推迟到子类

Reference

UML

Python类总结

2018-10-21T13:52:00+08:00

Class

类是方法和数据的集合，每个类有多个类实例，类实例有各自的属性保持各自的状态，类实例有类方法来修改类状态。

Namespace and Scope

namespace(命名空间)是变量名到对象的映射，Python中的命名空间包括：the set of built-in names, global names in a module and the local names in a function invocation. 不同命名空间中定义的变量名是没有关系的

By the way, I use the word attribute for any name following a dot — for example, in the expression z.real, real is an attribute of the object z.

不同命名空间创建时间和生命周期不同，包含built-in names的命名空间在Python解释器启动时建立，并且永远不会被删除。模块的全局命名空间当模块定义被读入时创建，函数内的命令空间在函数被调用时创建，函数执行结束时销毁。

scope(作用域)是命名空间能被直接访问的部分，包括:

the innermost scope, which is searched first, contains the local names
the scopes of any enclosing functions, which are searched starting with the nearest enclosing scope, contains non-local, but also non-global names
the next-to-last scope contains the current module’s global names
the outermost scope (searched last) is the namespace containing built-in names

这里要区分global, nonlocal之间的差异，如果一个变量被声明为global,则直接对该变量的所有引用和赋值发生在模块的global names作用域中。如果一个变量被声明为nonlocal, 则表示该变量在嵌套的作用域中。其他情况下，同名变量是只读的，如果对同名变量写入，则为该变量创建一个新的局部变量

def scope_test():
    def do_local():
        spam = "local spam"

    def do_nonlocal():
        nonlocal spam
        spam = "nonlocal spam"

    def do_global():
        global spam
        spam = "global spam"

    spam = "test spam"
    do_local()
    print("After local assignment:", spam)
    do_nonlocal()
    print("After nonlocal assignment:", spam)
    do_global()
    print("After global assignment:", spam)

scope_test()
print("In global scope:", spam)

输出结果是:

After local assignment: test spam
After nonlocal assignment: nonlocal spam
After global assignment: nonlocal spam
In global scope: global spam

Class definition syntax

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

Class object

类对象支持两种类型的操作:attribute references and instantiation. * attribute references通过.运算符实现，obj.attribute * 实例化通过x = MyClass()实现

Instance object

The only operations understood by instance objects are attribute references. There are two kinds of valid attribute names, data attributes and methods.

### Class and Instance Variables

实例变量是各个实例独有的，而类变量是该类的所有实例所共有的

class Dog:

    kind = 'canine'         # class variable shared by all instances

    def __init__(self, name):
        self.name = name    # instance variable unique to each instance

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.kind                  # shared by all dogs
'canine'
>>> e.kind                  # shared by all dogs
'canine'
>>> d.name                  # unique to d
'Fido'
>>> e.name                  # unique to e
'Buddy'

### Inheritance

python class DerivedClassName(BaseClassName): <statement-1> . . . <statement-N>

There’s nothing special about instantiation of derived classes: DerivedClassName() creates a new instance of the class. Method references are resolved as follows: the corresponding class attribute is searched, descending down the chain of base classes if necessary, and the method reference is valid if this yields a function object.

Derived classes may override methods of their base classes. Because methods have no special privileges when calling other methods of the same object, a method of a base class that calls another method defined in the same base class may end up calling a method of a derived class that overrides it. (For C++ programmers: all methods in Python are effectively virtual.)

An overriding method in a derived class may in fact want to extend rather than simply replace the base class method of the same name. There is a simple way to call the base class method directly: just call BaseClassName.methodname(self, arguments). This is occasionally useful to clients as well. (Note that this only works if the base class is accessible as BaseClassName in the global scope.)

Python has two built-in functions that work with inheritance:

Use isinstance() to check an instance’s type: isinstance(obj, int) will be True only if obj.class is int or some class derived from int. Use issubclass() to check class inheritance: issubclass(bool, int) is True since bool is a subclass of int. However, issubclass(float, int) is False since float is not a subclass of int.

矩阵复习

2018-10-20T20:48:00+08:00

一些有用的结论

实对称阵可以正交对角化
特征值 $\lambda_i$的几何重数是$(\lambda I-A)x=0$的基础解系的个数
特征值 $\lambda_i$的代数重数$n_i$是$|\lambda I-A|=\Pi_{i=1}^s(\lambda-\lambda_i)^{n_i}$
矩阵的行列式是所有特征值的乘积
矩阵的迹是所有特征值的和
A可逆 $\leftrightarrow$ 0不是A的特征值
任何特征值的几何重数不超过其代数重数
相似矩阵具有相同的特征多项式，也具有相同的特征值

特征向量

属于不同特征值的特征向量线性无关
n阶矩阵A可以对角化 $\leftrightarrow$ A有n个线性无关的特征向量 $\leftrightarrow$ $F^n$有一组由A的特征向量组成的基 $\leftrightarrow$ A的每个特征值的几何重数等于代数重数，特别的，若A有n个不同的特征值，则A可以对角化

空间

设$\alpha_1, \alpha_2, \cdots, \alpha_n$是一组标准正交基，则矩阵$Q=(\alpha_1, \alpha_2, \cdots, \alpha_n)$称为酉矩阵，实的酉矩阵称为正交矩阵
酉矩阵的逆矩阵是其共轭转置矩阵
正交矩阵的逆矩阵是其转置矩阵
复共轭对称矩阵称为Hermite矩阵
Hermite矩阵的特征值都为实数，且属于不同特征值的特征向量彼此正交
设A是n阶Hermite矩阵，则下列条件等价
- A正定
- A的特征值均为正实数

pelican blog搭建

2018-10-20T16:32:00+08:00

Installation

pip install pelican
pip install Markdown
pelican-quickstart to build a quick start version project
[Optional] pip install typogrify

Usage

blog metadata

Title: My title
Date: 2010-12-03 10:20
Modified: 2010-12-05 19:30
Category: Python
Tags: pelican, publishing
Slug: my-post
Authors: Alexis Metaireau, Conan Doyle
Summary: Short version for index and feeds

This is the content of my blog post.

make regenerate
make serve
make devserve

Reference

pelican

typogrify

Matrix Calculus

2018-10-20T16:03:00+08:00

Matrix Calculus

Vector-by-Vector

$\frac{\partial a}{\partial x} = 0$
$\frac{\partial x}{\partial x} = I$
$\frac{\partial x}{\partial x} = A$
$\frac{\partial x^TA}{\partial x} = A^T$
$\frac{\partial au(x)}{\partial x} = a\frac{\partial u}{\partial x}$

Scalar-by-Vector

$\frac{\partial a^Tx}{\partial x} = a^T$
$\frac{\partial u^Tv}{\partial x} = u^T\frac{\partial v}{\partial x} + v^T\frac{\partial u}{\partial x}$
$\frac{\partial u^TAv}{\partial x} = u^TA\frac{\partial v}{\partial x} + v^TA^T\frac{\partial u}{\partial x}$
$\frac{\partial x^TAx}{\partial x} = x^T(A^T + A)$

Reference

Matrix calculas

Markdown语法介绍

2018-10-14T21:14:00+08:00

This is a markdown file This is a markdown fileThis is a markdown file This is a markdown file This is a markdown file This is a markdown file

标题
引用
列表
代码
强调
链接
表格
分割线
图片
Reference

标题

Markdown共支持六级标题:

    # 一级标题
    ## 二级标题
    ### 三级标题
    #### 四级标题
    ##### 五级标题
    ###### 六级标题

引用

通过在段落的第一行最前面加上>来使用引用:

这是一个引用

这是二级引用

列表

列表项目一般放在最左边，项目标记后面要接一个空格

无序列表: 使用*, +或者-标记

这是无序列表
这也是无序列表

有序列表: 使用数字接一个英文句话

有序列表
有序列表

代码

使用“`来包裹代码块即可

这是一段代码

强调

这是斜体, 这是加粗

链接

[说明](链接url)

表格

First Header	Second Header	Third Header
Content Cell	Content Cell	Content Cell
Content Cell	Content Cell	Content Cell

分割线

可以使用三个以上-符号制作分割线

ABA
---
BAB

图片

![Alt text](/path/img.jpg)

Reference

Markdown语法介绍

二分搜索的各种写法

2018-10-14T21:04:00+08:00

对于已排序的数组x[0..n-1]，想查找数t，若t在x中则返回其下标（如有多个重复，返回其中之一)，若t不在x中则返回-1。

    int binarysearch(vector<int> x, int t) {
    int n = x.size();
    int l = 0, u = n - 1, m;
    while (l <= u) {
        m = l + (u - l) / 2;
        if (x[m] < t) l = m + 1;
        else if (x[m] == t) return m;
        else u = m - 1;
    }
    return -1;
    }

如果我们希望确定t在数组中第一次出现的位置，我们可以在循环中保持x[l]=t 的特性，我们可以做以下修改:

    int binarysearch2(vector<int> x, int t) {
        int n = x.size();
        int l = -1, u = n;
        while (l + 1 != u) {
            // x[l] < t && x[u] >= t && l < u
            int m = l + (u - l) / 2;
            if (x[m] < t) l = m;
            else u = m;
        }
        // l + 1 = u && x[l] < t && x[u] >= t
        int p = u;
        if (p >= n || x[p] != t) p = -1;
        return p;
    }

其实上述代码的p或者u就代表第一个大于或等于t的元素的位置，即STL里面的lower_bound函数。

    int binarysearch3(vector<int> x, int t) {
        int n = x.size();
        int l = -1, u = n;
        while (l + 1 != u) {
            // x[l] < t && x[u] >= t && l < u
            int m = l + (u - l) / 2;
            if (x[m] < t) l = m;
            else u = m;
        }
        // l + 1 = u && x[l] < t && x[u] >= t
        return u;
    }

最后如果要实现STL里面的upper_bound函数，即返回第一个大于t的元素的位置我们可以这样做:

    int binarysearch4(vector<int> x, int t) {
        int n = x.size();
        int l = -1, u = n;
        while (l + 1 != u) {
            // x[l] <= t && x[u] > t && l < u
            int m = l + (u - l) / 2;
            if (x[m] > t) u = m;
            else l = m;
        }
        // l + 1 = u && x[l] <= t && x[u] > t
        return u;
    }

写二分搜索函数的关键是保持循环不变式，即保证t与区间两端点之间的大小关系不变，这样就可以根据区间两端的大小关系来判断其是否是你需要的结果了。

统计推断复习

2018-10-14T20:52:00+08:00

总体

所研究对象的全体组成的集合称为总体。组成总体的每个元素(成员)称为个体。与总体相关的特征值称为参数。

样本

总体的任何一个子集合，称为从总体中抽取的样本。样本中包含个体的数目称为样本容量，通常记为n。因为抽取样本是为了对总体特征进行推断，所以必须对抽样方法提出一定要求。

随机性: 总体中每个个体被抽到的概率是相等的。
独立性: 每次观察X_1, X_2, … , X_n是相互独立的随机变量。
同分布性: 样本与总体同分布。

满足上述条件的抽样方法称为简单随机抽样

统计量

如果由样本构造一个函数g(X_1, X_2, …, X_n), 且不含有任何未知参数，则称g(X_1, X_2, …, X_n)为统计量。

常用的统计量包括:

样本均值
样本方差
样本相关系数
样本偏度和样本峰度
样本变异系数

Git命令整理

2018-10-14T15:31:00+08:00

首先需要明确三个概念，Git中的文件有三种状态: 已提交(commited), 已修改(modified)和已暂存(staged), 这里前两个概念比较好理解，已提交表示数据已保存(执行git commit指令后)，已修改表示修改了文件但还没有保存数据，而已暂存表示已经对当前经过修改的文件做了标记（执行git add filename指令后)
与之相对的Git项目有三个不同的工作区的概念: Git仓库、工作目录和暂存区域，之间的关系可以参考Git基础
在首次使用Git前需要进行一些简单的配置:
- 设置提交中使用的用户名:
  - git config --global user.name "yourname"
- 设置提交中使用的邮件地址:
  - git config --global user.email "youremail@emai.com"
- 你可以使用以下指令检查你的配置: *git config --list
常用指令
- 初始化仓库:
  - git init
- 跟踪文件(或者添加文件到暂存区):
  - git add filename git add . //添加所有文件
- 提交文件(将暂存区文件保存到本地):
  - git commit -m "your commit message"
- 克隆仓库:
  - git clone url
  - git clone --recursive url下载所有submodule
- 查看当前文件处于哪个状态:
  - git status
- 忽略文件:
  - 修改.gitignore文件，可控制不希望被Git管理的文件
- 查看文件中具体更新细节:
  - git diff // 比较工作目录当前文件与暂存区域之间的差异
  - git diff --staged // 查看已暂存的将要添加到下次提交里的内容
- 跳过暂存区域直接提交:
  - git commit -a -m "your commit message"
- 删除本地文件和暂存区文件:
  - git rm filename
- 删除暂存区文件但保留本地文件:
  - git rm --cached filename
- 查看提交历史:
  - git log
- 重新提交:
  - git commit --amend
- 取消暂存的文件(注意与git rm --cached的区别):
  - git reset HEAD filename
- 撤销对文件的修改:
  - git checkout -- filename
- 查看远程仓库:
  - git remote -v
- 添加远程仓库:
  - git remote add <shortname> <url>
- 从远程仓库抓取文件但是不合并:
  - git fetch [remote-name]
- 从远程仓库抓取文件并合并:
  - git pull
- 推送到远程仓库:
  - git push [remote-name] [branch-name]
- 查看远程仓库:
  - git remote show [remote-name]
- 远程仓库重命名:
  - git remote rename [original-name] [new-name]
- 移除远程仓库:
  - git remote rm [original-name]
分支指令
- 创建分支:
  - git branch [branch-name]
- 切换分支:
  - git checkout [branch-name]
- 新建并切换分支:
  - git checkout -b [branch-name]
  - git checkout --orphan [branch-name] 创建一个全新分支，分支历史从零开始
- 合并到当前分支:
  - git merge [branch-name]
- 删除分支:
  - git branch -d [branch-name]
- 重命名分支:
  - git branch -m [new-branch-name]
- 推送分支:
  - git push [remote] [branch]
- 避免输入密码:
  - git config --global credential.helper cache
- 跟踪远程分支:
  - git checkout -b [branch-name] [remote-name]/[branch-name]
  - git checkout --track [remote-name]/[branch-name]
- 修改上游分支:
  - git checkout -u [remote-name]/[branch-name]
- 查看所有跟踪分支:
  - git branch -vv
- 变基:
  - git rebase [branch-name]

VS Code使用Anaconda Prompt作为默认terminal

2018-10-07T21:03:00+08:00

Solution

在你自己的User settings中添加下列代码

"terminal.integrated.shell.windows": "C:\\WINDOWS\\System32\\cmd.exe",
"terminal.integrated.shellArgs.windows": [
    "/K", "C:\\Users\\ben\\Anaconda3\\Scripts\\activate.bat C:\\Users\\ben\\Anaconda3"       
]

其中terminal.integrated.shellArgs.windows后的参数可以通过右键点击Anaconda Prompt选择属性,复制目标一栏中后半部分路径获得

Reference

http://mscodingblog.blogspot.com/2017/08/setup-integrated-terminal-in-vs-code-to.html

利用VS Code Snippets生成C++头文件保护符

2018-10-07T20:54:00+08:00

Solution

将下列代码贴入你的snippets中，然后在cpp文件中输入pre+tab即可自动生成相关头文件

{
    "Preprocessor of cpp file":{
        "prefix": "pre",
        "body": [
            "#ifndef ${TM_FILENAME/(.*)(\\.)+(.*)/$${1:/upcase}_${3:/upcase}/}",
            "#define ${TM_FILENAME/(.*)(\\.)+(.*)/$${1:/upcase}_${3:/upcase}/}",
            "class ${TM_FILENAME/([a-z])(.*)(\\.)+(.*)/${1:/upcase}${2}/} {",
                "$1",
            "};",
            "#endif"
        "description": "Preprocessor of cpp and hpp file"
    }
}

每一个snippet由prefix, body和description组成,其中prefix表示你的快捷键符，body是你的snippet内容。 $TM_FILENAME是系统定义的变量，表示当前文件的完整文件名，然后利用正则表达式生成对应的头文件保护符。

解决VS Code中markdown的snippet无法自动补全

原因是markdown文件中的quickSuggetions默认是false, 因此在user setting中添加下列代码即可

 "[markdown]":  {
    "editor.quickSuggestions": true
  },

Reference

https://code.visualstudio.com/docs/editor/userdefinedsnippets#_global-snippets https://github.com/Microsoft/vscode/issues/26108

解决VS Code在ubuntu下terminal无法显示下划线的问题

2018-10-07T20:47:00+08:00

Solution

输入ctrl + shift + P 打开命令面板搜索 Open User Settings - Open settings.json

添加"editor.fontFamily": "'Ubuntu Mono', monospace"即可

VS Code显示数学公式

输入ctrl + shift + X搜索 Markdown+Math 安装即可。一共有4种形式的texmath语法，我们可以按照自己的需求选择,可以通过下列代码修改

"mdmath.delimiters": "dollars" // 这里输入你需要的语法

Reference

https://github.com/Microsoft/vscode/issues/38133

C++ STL常用数据结构整理

2018-10-07T20:21:00+08:00

vector
- 插入push_back(), 时间复杂度O(1)
- 删除erase(iterator position), 时间复杂度O(n)取决于删除的位置
- 支持随机访问
stack
- 插入push(), 时间复杂度O(1)
- 删除pop(), 时间复杂度O(1)
- 不支持随机访问
queue
- 插入push(), 时间复杂度O(1)
- 删除pop(), 时间复杂度O(1)
- 不支持随机访问
list(双向链表)
- 插入push_front(), push_back(), 时间复杂度O(1)
- 删除pop_front(), pop_back(), erase(iterator position), 时间复杂度O(1)
- 不支持随机访问
forward_list(单链表)
- 插入push_front(), insert_after(), 时间复杂度O(1)
- 删除pop_front(), erase_after(), 时间复杂度O(1)
- 不支持随机访问
deque(双端队列)
- 插入push_front(), push_back(), 时间复杂度O(1)
- 删除push_back(), pop_back(), 时间复杂度O(1)
- 支持随机访问
- 相对于list, deque在中间位置插入速读较慢
priority_queue(优先级队列)
- 插入push(), 时间复杂度O(log(n))
- 删除pop(), 时间复杂度O(log(n))
- 内部实现支持随机访问，但是优先级队列不支持
set(集合)
- 利用二叉搜索树实现
- 插入insert(), 时间复杂度O(log(n)), 如果给出插入位置则时间复杂度为O(1)
- 删除erase(position), 时间复杂度O(1); erase(val), 时间复杂度O(log(n))
- 搜索find(), 时间复杂度O(log(n))
- 支持lower_bound(), upper_bound(), equal_range()操作
unordered_set
- 利用哈希表实现
- 插入insert(), 时间复杂度平均情况O(1)，最坏情况O(n)
- 删除erase(), 时间复杂度平均情况O(1), 最坏情况O(n)
- 搜索find(), 时间复杂度平均情况O(1), 最坏情况O(n)
- 不支持lower_bound(), upper_bound()操作
multiset
- 能包括多个有相同值的元素
- 利用二叉搜索树实现
- 插入insert(), 时间复杂度O(log(n)), 如果给出插入位置则时间复杂度为O(1)
- 删除erase(position), 时间复杂度O(1); erase(val), 时间复杂度O(log(n))
- 搜索find(), 时间复杂度O(log(n))
- 支持lower_bound(), upper_bound(), equal_range()操作
unordered_multiset
- 能包括多个有相同值的元素
- 利用哈希表实现
- 插入insert(), 时间复杂度平均情况O(1)，最坏情况O(n)
- 删除erase(), 时间复杂度平均情况O(1), 最坏情况O(n)
- 搜索find(), 时间复杂度平均情况O(1), 最坏情况O(n)
- 不支持lower_bound(), upper_bound()操作
map
- 利用二叉搜索树实现
- 插入insert(), 时间复杂度O(log(n)), 如果给出插入位置则时间复杂度为O(1)
- 删除erase(position), 时间复杂度O(1); erase(val), 时间复杂度O(log(n))
- 搜索find(), 时间复杂度O(log(n))
- 支持lower_bound(), upper_bound(), equal_range()操作
- key-value对，支持[]访问
unordered_map
- 利用哈希表实现
- 插入insert(), 时间复杂度平均情况O(1)，最坏情况O(n)
- 删除erase(), 时间复杂度平均情况O(1), 最坏情况O(n)
- 搜索find(), 时间复杂度平均情况O(1), 最坏情况O(n)
- 不支持lower_bound(), upper_bound()操作
- key-value对，支持[]访问
multimap
- 能包括多个有相同值的元素
- 利用二叉搜索树实现
- 插入insert(), 时间复杂度O(log(n)), 如果给出插入位置则时间复杂度为O(1)
- 删除erase(position), 时间复杂度O(1); erase(val), 时间复杂度O(log(n))
- 搜索find(), 时间复杂度O(log(n))
- 支持lower_bound(), upper_bound(), equal_range()操作
- key-value对，不支持[]访问
unordered_multimap
- 能包括多个有相同值的元素
- 利用哈希表实现
- 插入insert(), 时间复杂度平均情况O(1)，最坏情况O(n)
- 删除erase(), 时间复杂度平均情况O(1), 最坏情况O(n)
- 搜索find(), 时间复杂度平均情况O(1), 最坏情况O(n)
- 不支持lower_bound(), upper_bound()操作
- key-value对，不支持[]访问

Beta's Note

一个简单的聊天机器人 - “AI 巴菲特”

配置方法

Tips

C++ 如何实现Java风格的c++入口函数

C++并发编程(IV)

条件变量

原子操作与内存模型

内存顺序

C++并发编程(III)

std::async和std::future

std::promise对象

std::packaged_task对象

C++并发编程(II)

C++ threading

互斥量和自旋锁

C++并发编程(I)

C++多态和虚函数(I)

什么是多态

什么是虚函数

什么是虚函数表

C++模板(I)

Make总结

Make

Make rules

Reference

如何测试python代码

Profiling Python

Timeit

Profiler

Line-profiler

Reference

设计模式

Head first设计模式

策略模式

观察者模式

装饰者模式

工厂方法模式

Reference

Python类总结

Class

Namespace and Scope

Class definition syntax

Class object

Instance object

矩阵复习

一些有用的结论

特征向量

空间

pelican blog搭建

Installation

Usage

Reference

Matrix Calculus

Matrix Calculus

Vector-by-Vector

Scalar-by-Vector

Reference

Markdown语法介绍

Table of Contents

标题

引用

列表

代码

强调

链接

表格

分割线

图片

Reference

二分搜索的各种写法

统计推断复习

总体

样本

统计量

Git命令整理

VS Code使用Anaconda Prompt作为默认terminal

Solution

Reference

利用VS Code Snippets生成C++头文件保护符