小编woh*_*tad的帖子

我的教授曾经说过，if 语句相当慢，应该尽可能避免。我正在用 OpenGL 制作一个游戏，我需要很多它们。在我的测试中，通过短路将 if 语句替换为 AND 是有效的，但是它更快吗？

bool doSomething();

int main()
{

  int randomNumber = std::rand() % 10;

  randomNumber == 5 && doSomething();

  return 0;
}

bool doSomething()
{
    std::cout << "function executed" << std::endl;

    return true;
}

我的目的是在渲染器的绘制函数中使用它。我的模型应该有标志，如果标志为真，则应该执行某个函数。

我正在尝试使用std::visit来检查std::variant.
首先，我声明变体和变体的基（可调用）访问者类：

#include <iostream>
#include <string>
#include <variant>


using Amalgamation = std::variant<int, bool, std::string>;

class BaseVisitor {
public:
    virtual void operator()(int) {}
    virtual void operator()(bool) {}
    virtual void operator()(const std::string&) {}
};

其次，我定义了另一个从上面的基类派生的访问者类：

class CheckBooleanVisitor
    : public BaseVisitor {
public:
    CheckBooleanVisitor()
        : m_isBoolean(false) {
    }

    virtual void operator()(bool) override { // WHERE THE OVERRIDING TAKES PLACE
        m_isBoolean = true;
    }

    bool isBoolean() const {
        return m_isBoolean;
    }
};

我使用这个“派生”访问者类来访问如下变体：

int main() {
    Amalgamation a(0);
    Amalgamation b(false); …

// CPP file

template<typename T>
void foo()
{
}

// Use the template only in this CPP as foo<int>, foo<char>, etc.

假设我有 CPP 文件，并且有一个foo仅在该 CPP 文件内部使用的模板函数。我是否理解正确，如果我不将模板放入匿名名称空间或不创建它static，则在此 CPP 文件中使用/创建的其实例化foo<int>{}（例如，foo<char>{}等）将具有外部链接，即将在外部看到。那么，我最好将模板静态化（如下所示）还是将其放在匿名名称空间中，这是真的吗？

// CPP file

template<typename T>
static void foo()
{
}

有没有保存到文件std::bytes 中的 C++ 类？我已经使用了std::ofstream，但是需要强制转换才能执行它：

std::byte bt{ 1 };
std::ofstream ofs{};
ofs.write(reinterpret_cast<const char*>(bt), 1);

你看：reinterpret_cast<const char*>？是否有其他std::byte无需任何强制转换即可保存的 C++ 类？

我刚刚了解到std::lock_guard，我想知道为什么它是一个模板。
到目前为止我只见过尖括号内的std::lock_guard<std::mutex>with 。std::mutex

如何清除priority_queue使用用户定义的比较？

从std::priority_queue文档priority_queue中，我减少了我需要的情况的使用（=带有用户定义比较的队列）

>> cat test.cpp \n#include <functional>\n#include <queue>\n#include <vector>\n#include <iostream>\n#include <utility>\n\nauto queue_cmp = [](std::pair<int, double> const& lhs,\n                    std::pair<int, double> const& rhs) {\n    return lhs.second > rhs.second; // Custom order.\n};\ntypedef std::priority_queue<std::pair<int, double>,\n                            std::vector<std::pair<int, double>>,\n                            decltype(queue_cmp)> custom_queue;\n\ntemplate<typename T>\nvoid print_queue(T q) { // NB: pass by value so the print uses a copy\n    int s = 0;\n    while(!q.empty()) {\n        std::pair<int, double> elem = q.top();\n        std::cout << s << ": " << elem.first << ", " …

std::atomic<int>为了比较++ 和std::mutexprotected ++的性能差异int，我有这个测试程序：

#include <iostream>
#include <atomic>
#include <mutex>
#include <thread>
#include <chrono>
#include <limits>
using namespace std;
#ifndef INT_MAX
const int INT_MAX = numeric_limits<std::int32_t>::max();
const int INT_MIN = numeric_limits<std::int32_t>::min();
#endif
using std::chrono::steady_clock;
const size_t LOOP_COUNT = 12500000;
const size_t THREAD_COUNT = 8;
int intArray[2] = { 0, INT_MAX };
atomic<int> atomicArray[2];
void atomic_tf() {//3.19s
    for (size_t i = 0; i < LOOP_COUNT; ++i) {
        atomicArray[0]++;
        atomicArray[1]--;
    }
}
mutex m;
void mutex_tf() {//0.25s
    m.lock(); …

我在频繁使用的 if 上使用[[likely]]/ 。[[unlikely]]我最近有一个循环，其中条件很少满足，即循环很少进入或重复。
是否可以[[unlikely]]循环播放？在 en.cppreference.com 上我没有找到任何相关内容。

如果我有以下两个课程：

#include <cstdlib>

class Parent
{
    protected:
        int* mem = (int*) std::malloc(5); // pointer to dynamically-stored object
    public:
        Parent() {};
        virtual ~Parent()
        {
            delete(mem);
        }
};

class Child: public Parent
{
    public:
        Child() {};
        ~Child()
        {
            delete(mem);
        }
};

int main(void)
{
    Child* c = new Child();
    delete(c);
}

不应该打电话delete调用该类的实例Child导致分段错误，因为父级的析构函数也会在子级析构函数之后自动调用？如果是这样，解决方案是否是类Child只处理释放类“拥有”的动态分配的内存（即不在 的析构函数中Child删除并让其处理它）？memChildParent

我运行了我的 main 函数，并预计会发生分段错误，因为mem被释放了两次 - 一次在 的Child析构函数中，另一次在Parent析构函数中。没有发生错误，这让我感到惊讶。谁能解释一下为什么吗？

我经常编写具有类似于以下签名的工厂：

std::unique_ptr<AbstractType> createUnique(IDType id);
std::shared_ptr<AbstractType> createShared(IDType id);

前者会做类似的事情：

switch (id)
{
case kID1:
    return std::make_unique<Type1>();
}

而后者

switch (id)
{
case kID1:
    return std::make_shared<Type1>();
}

那么，这两个函数之间的唯一区别是使用的“make”函数（make_shared或make_unique）和返回类型（shared_ptr或unique_ptr）。这会导致代码重复。

我想知道如何编写一个create接受指针类型和“make”函数类型并使用它们的模板化函数。就像是：

template <typename PTR, typename MAKE>
PTR create(IDType id)
{
    switch (id)
    {
    case kID1:
        return MAKE<Type1>();
    }
}

我知道以上不是有效的代码。

另外，我知道 astd::shared_ptr可以从 an 创建，std::unique_ptr反之亦然，但我这个工厂将用于不同的应用程序，其中一个可能使用 a shared_ptr，另一个可能使用unique_ptr. 这样，代码就可以重复使用，而且对于特定的用例也很有效。