小编woh*_*tad的帖子

我将随机数生成器应用于我的代码，尽管当我第二次或第三次运行代码时，生成的第一个数字没有改变。然而，其他数字发生了变化，问题仅在于第一个值。我正在使用代码块；Cygwin GCC 编译器 (c++ 17)。利用时间播种。

#include <iostream> 
#include <random>
#include <ctime>
    
int main()
{
    std::default_random_engine randomGenerator(time(0));
    std::uniform_int_distribution randomNumber(1, 20);
    int a, b, c;
    a = randomNumber(randomGenerator); 
    b = randomNumber(randomGenerator); 
    c = randomNumber(randomGenerator);
    std::cout<<a<<std::endl;
    std::cout<<b<<std::endl;
    std::cout<<c<<std::endl;

    return 0;
}

在这种情况下，当我第一次运行代码时，它可能会产生类似 a = 4、b = 5、c = 9 的结果。第二次和以后的时间 (a) 仍为 4，但 (b) 和 (c) 不断变化。

我有类似下面的东西，但无法编译它。我不明白为什么当我的变量可以保存不同类型时我不能有不同的类型？

我的代码：

#include <boost/variant.hpp>
#include <iostream>

typedef boost::variant<int, float, double, std::string> MultiType;

int main() {
    int a = 1;
    std::string b = "b";
    bool c = true;
    MultiType d = c ? a : b;
    return 0;
}

错误：

错误 C2446 ':'：没有从 'std::string' 到 'int' 的转换

我刚刚了解到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 << ", " …

如果我有以下两个课程：

#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析构函数中。没有发生错误，这让我感到惊讶。谁能解释一下为什么吗？

所以我知道要循环打印一些东西，代码如下所示：

for(int I = 0; I < num; ++I)...

并打印对象向量：

for(Square sq : squares)...

（如果我有一个类 Square 并且我创建了对象 sq 并且 squares 是向量的名称）

但是，如果我希望输出如下所示，我该如何编写代码：

方格1面积：3 方格2面积：6 方格3面积：9

更清楚地说：我的问题是，如何将第一个示例中的“I”合并到打印对象的循环中？

我有自定义数组构造函数，如下所示：

rtc::ArrayView<const uint8_t> frame,
rtc::ArrayView<uint8_t> encrypted_frame,
uint8_t unencrypted_bytes = 10;

我如何有效地循环进入这些帧并对其进行处理？仅 for 循环是可能的选择吗？如果我们只想复制帧而不进行预处理，我知道我们可以使用std::copy. 有什么方法可以让这个迭代器处理更高效吗？

  // // Copy rest of frame
  // std::copy(frame.begin() + unencrypted_bytes, frame.begin() +
  // (encrypted_frame.size() - 41),
  //           encrypted_frame.begin() + unencrypted_bytes);

  // Doing XOR for Frame
  for (size_t i = unencrypted_bytes; i < encrypted_frame.size() - 41; i++) {
    // encrypted_frame[i] = i;
    RTC_LOG(LS_INFO) << "Ivan, original frame Before XOR : " << i << " "
                     << frame[i];
    encrypted_frame[i] = frame[i] ^ fake_key_;
    RTC_LOG(LS_INFO) << …

我有这样的课程：

struct S{
    void method1(int *a){
       // use a
    }

    void method2(int *a){
       // use a
    }
};

为了避免分配，我正在执行以下操作：

std::array<int, 100> a;
S s;
s.method1(a.data());

然而，如果我能够做到，而不需要制作所有方法模板，那就更好了。

std::array<int, 100> a;
S s;
s.method1(a);

在 C++20 中我可以使用std::span，但目前我也想避免它。

有什么简单的方法来定义一些能够转换/转换的运算符，但只能在类内部？

我有这段代码，我不明白为什么我需要delete然后pop_back()。
我可以只做1次手术吗？

struct T
 {
    T(int n):x(n){};
    int print() {
       return x; 
    };
    private:
        int x;
 };

int main(int argv,char** argc)
{
    std::vector t = { new T(1),new T(2)};
    delete t.back();
    std::cout << t.size() << std::endl;
    std::cout << t.back()->print() << std::endl;

    t.pop_back();
    std::cout << t.size() << std::endl;
    std::cout << t.back()->print() << std::endl;

    return 0;
}

输出 - 正如您所看到的，delete向量看起来仍然保留着没有对象的元素：

2
179185600
1
1 

我的问题是为什么我需要delete然后删除，不能在单个命令中完成相同的操作吗？

下面的代码中，是否需要pthread_yield()在主线程阻塞等待时调用pthread_join()？

void *myThread(void *result)
{
   //do something here
   return 0;
}

int main()
{
   pthread_t tid;
   void *status = 0;
   int result;

   pthread_create(&tid, NULL, myThread, &result);
   
   // do I need pthread_yield() here?
   
   pthread_join(tid, &status);

   return 0;
}

如果不是，什么是有效的用例pthread_yield()？我能想到的大多数基本情况，操作系统/调度程序已经自动处理了。