我想知道在不同的C++编译器中使用了哪些C++标准库.我试图搜索它,但找不到一个全面的列表.
我知道Dinkumware的实现由msvc和icc使用,libstdc ++由gcc使用,libc ++用于clang.但是Digital Mars C++,Embarcadero的bcc,还是IBM的xlC++呢？
在下面的例子中(理想化的"游戏")有两个线程.更新数据并将RenderThread其"呈现"到屏幕的主线程.我需要的是那两个要同步的东西.我没有能力运行几次更新迭代而不为它们中的每一个运行渲染.
我使用a condition_variable来同步这两个,所以理想情况下,更快的线程将花费一些时间等待更慢.但是,如果其中一个线程在很短的时间内完成迭代,则条件变量似乎不起作用.它似乎很快就会重新获取互斥锁的锁定,然后wait另一个线程才能获取它.即使notify_one被称为
#include <iostream>
#include <thread>
#include <chrono>
#include <atomic>
#include <functional>
#include <mutex>
#include <condition_variable>
using namespace std;
bool isMultiThreaded = true;
struct RenderThread
{
RenderThread()
{
end = false;
drawing = false;
readyToDraw = false;
}
void Run()
{
while (!end)
{
DoJob();
}
}
void DoJob()
{
unique_lock<mutex> lk(renderReadyMutex);
renderReady.wait(lk, [this](){ return readyToDraw; });
drawing = true;
// RENDER DATA
this_thread::sleep_for(chrono::milliseconds(15)); // simulated render time
cout << "frame " …我在新版本的gcc(4.9+)上遇到这个奇怪的编译错误.
这是代码:
#include <iostream>
#include <vector>
#include <string>
#include <memory>
#include <map>
using namespace std;
struct ptrwrap
{
unique_ptr<int> foo;
};
template <typename T>
struct holder
{
holder() = default;
holder(const holder& b)
: t(b.t)
{
}
holder(holder&& b)
: t(std::move(b.t))
{
}
holder& operator=(const holder& h)
{
t = h.t;
return *this;
}
holder& operator=(holder&& h)
{
t = std::move(h.t);
return *this;
}
T t;
};
struct y_u_no_elision
{
holder<ptrwrap> elem;
};
typedef map<std::string, y_u_no_elision> mymap;
mymap foo();
int …我有这个简单的示例持有者类,它明确是不可移动的:
template <typename T>
struct holder
{
holder() = default;
holder(const holder& b)
: t(b.t)
{
}
holder(holder&& b) = delete;
holder& operator=(const holder& b)
{
t = b.t;
return *this;
}
holder& operator=(holder&& b) = delete;
T t;
};
因此,以下类型也是隐式不可复制的(因为std::unique_ptr这样):
typedef holder<std::unique_ptr<int>> ptr;
所以,正如我所期望的那样,如果我有一个函数ptr foo();,可以通过它调用它,auto x = foo;或者ptr x; x = foo();产生一个编译错误,即调用一个已删除的函数.
但是,如果我引入另一种类型的ptr矢量,如下所示:
typedef std::vector<ptr> vec;
vec foo();
int main()
{
vec x = foo();
x = foo();
return 0;
} …我有一个应用程序对象，它可以从运行在多个线程中的多个服务接收消息。该消息由服务线程中的调度程序对象的实例在内部进行调度。该应用程序可以随时更改当前调度程序。调度员永远不会被摧毁。服务永远不会超过应用程序。
这是一个示例代码
#include <iostream>
#include <thread>
#include <atomic>
#include <cstdlib>
#include <functional>
using namespace std;
using Msg = int;
struct Dispatcher
{
virtual ~Dispatcher() = default;
virtual void dispatchMessage(Msg msg) = 0;
};
struct DispatcherA : Dispatcher
{
void dispatchMessage(Msg msg)
{
cout << "Thread-safe dispatch of " << msg << " by A" << endl;
}
};
struct DispatcherB : Dispatcher
{
void dispatchMessage(Msg msg)
{
cout << "Thread-safe dispatch of " << msg << " by …所以我想用boost :: spirit :: qi编写一个......那么......不那么简单的解析器.我知道提升精神的基本知识,在过去的几个小时里第一次熟悉它.
基本上我需要解析这个:
# comment
# other comment
set "Myset A"
{
figure "AF 1"
{
i 0 0 0
i 1 2 5
i 1 1 1
f 3.1 45.11 5.3
i 3 1 5
f 1.1 2.33 5.166
}
figure "AF 2"
{
i 25 5 1
i 3 1 3
}
}
# comment
set "Myset B"
{
figure "BF 1"
{
f 23.1 4.3 5.11
}
}
set "Myset C"
{
include "Myset …我有一个函数,它找到给定整数的下一个2的幂.如果整数是2的幂,则返回功率.
非常直截了当:
char nextpow2if(int a)
{
char foo = char(32 - __builtin_clz(a));
bool ispow2 = !(a & a-1);
if (ispow2) --foo;
return foo;
}
但是在使用gcc 6和-O2进行编译之后,在检查生成的程序集之后,我发现cmovne在计算foo-1之后,这是用看似无用的指令编译的.更糟糕的是gcc5和更老版本我jne在代码中得到了一个实际的分支.
编译它的更快方法就像我编写了以下函数:
char nextpow2sub(int a)
{
char foo = char(32 - __builtin_clz(a));
bool ispow2 = !(a & a-1);
return foo - ispow2;
}
所有编译器都将此代码正确编译为最短(和最快)可能的程序集,sete并使用bool的减法.
为什么编译器无法优化第一个？这似乎是一个非常容易识别的案例.为什么gcc 5和更早版本将它编译成实际的jne分支？两个版本之间是否存在边缘情况,我看不到,这可能导致它们的行为不同？
PS:现场演示在这里
编辑:我没有用gcc 6测试性能,但是使用gcc 5,后者的速度提高了两倍(至少在合成性能测试中).这实际上是让我提出这个问题的原因.
我有几类,比如说A,B和C,和相应的标志HAS_A=1,HAS_B=2和HAS_C=4.是否有可能写一个类以这样的方式,其父母(由A,B和C)将通过这些标志的组合决定的？
例:
ParentsFromFlags<HAS_A | HAS_C> x;
// x ends up having the features of A and C
我知道我可以有多个可变的父母<typename... Parents>,但我想这是因为我要确保,如果A,B和C是类的父母,他们总是会出现一定的顺序.
我有一个类型X，它是可复制构造但不可复制分配的
struct X {
X();
X(const X&);
X& operator=(const X&) = delete; // !!
X(X&&) noexcept;
X& operator=(X&&) noexcept;
int data = 54;
};
我有“X”两个向量：a和b我想插入的所有内容b在前面a：
void add_to_front(std::vector<X>& a, const std::vector<X>& b) {
a.insert(a.begin(), b.begin(), b.end());
}
这在 msvc 上编译并按预期工作，但无法在 clang 和 gcc 上编译。我猜是由于 libc++ 和 libstdc++ 的糟糕实现，即使它永远不会被调用（或者，更糟糕的是，它会被调用！？），它们需要一些东西来编译。
我可以写一本手册回路emplace的元素b进入a，这将产生一个正确的结果，但这样的复杂性是A * B，而不是A + B，因为每次调用emplace将转移的所有元素a一遍又一遍。
那么有没有有效的方法呢？
以下C++程序预计会输出0.300000000000000040000:
cout << setprecision(40) << (0.1 + 0.2) << endl;
但是以下C#代码:
System.Console.WriteLine("{0:F40}", 0.1+0.2);
......未满意地输出0.3000000000000000000000000000000000000000,而它(预期)评估0.1+0.2 == 0.3为False.
'4'在哪里,我该如何输出？
我正在绘制几个与单个glDrawElements调用重叠的alpha混合三角形.
索引将三角形列回到前面,此顺序对于正确的可视化非常重要.
我可以依赖此操作的结果与使用不同的绘制调用以相同顺序绘制三角形时完全相同吗？
我问这个是因为我不确定某些硬件是否会进行某种优化,并且只使用索引来获取有关绘制的基元的信息并忽略实际的基本顺序.