GLFW的首字母缩写词代表什么？http://www.glfw.org/是主要网站,但我找不到任何线索.在SO上它有一个标签,但在描述中没有解释首字母缩略词.
下面的代码从一个被解释为float的零数组复制到另一个,并打印此操作的时间.正如我已经看到许多情况,其中无操作循环只是被编译器(包括gcc)优化掉了,我在等待更改我的复制数组程序的某些时候,它将停止进行复制.
#include <iostream>
#include <cstring>
#include <sys/time.h>
static inline long double currentTime()
{
timespec ts;
clock_gettime(CLOCK_MONOTONIC,&ts);
return ts.tv_sec+(long double)(ts.tv_nsec)*1e-9;
}
int main()
{
size_t W=20000,H=10000;
float* data1=new float[W*H];
float* data2=new float[W*H];
memset(data1,0,W*H*sizeof(float));
memset(data2,0,W*H*sizeof(float));
long double time1=currentTime();
for(int q=0;q<16;++q) // take more time
for(int k=0;k<W*H;++k)
data2[k]=data1[k];
long double time2=currentTime();
std::cout << (time2-time1)*1e+3 << " ms\n";
delete[] data1;
delete[] data2;
}
我用g ++ 4.8.1命令编译了这个g++ main.cpp -o test -std=c++0x -O3 -lrt.这个程序打印6952.17 ms给我.(我不得不设置ulimit -s 2000000它不会崩溃.)
我也尝试使用new自动VLA …
考虑以下结构:
struct vec4
{
union{float x; float r; float s};
union{float y; float g; float t};
union{float z; float b; float p};
union{float w; float a; float q};
};
像这样的东西似乎比如可以应用于GLM提供GLSL般的类型,如vec4,vec2等.
但是,尽管预期的用途是使这成为可能
vec4 a(1,2,4,7);
a.x=7;
a.b=a.r;
,它似乎是一个未定义的行为,因为,如这里引用的,
在联合中,最多一个数据成员可以在任何时间处于活动状态,也就是说,最多一个数据成员的值可以随时存储在并集中.
例如,使用仅仅定义类似下面的结构不是更好吗？
struct vec4
{
float x,y,z,w;
float &r,&g,&b,&a;
float &s,&t,&p,&q;
vec4(float X,float Y,float Z,float W)
:x(X),y(Y),z(Z),w(W),
r(x),g(y),b(z),a(w),
s(x),t(y),p(z),q(w)
{}
vec4()
:r(x),g(y),b(z),a(w),
s(x),t(y),p(z),q(w)
{}
vec4(const vec4& rhs)
:x(rhs.x),y(rhs.y),z(rhs.z),w(rhs.w),
r(x),g(y),b(z),a(w),
s(x),t(y),p(z),q(w)
{}
vec4& operator=(const vec4& rhs)
{ …假设我们将一些数据作为一个字节序列获得,并希望将该序列重新解释为一个结构(有一些保证数据确实是正确的格式).例如:
#include <fstream>
#include <vector>
#include <cstdint>
#include <cstdlib>
#include <iostream>
struct Data
{
std::int32_t someDword[629835];
std::uint16_t someWord[9845];
std::int8_t someSignedByte;
};
Data* magic_reinterpret(void* raw)
{
return reinterpret_cast<Data*>(raw); // BAD! Breaks strict aliasing rules!
}
std::vector<char> getDataBytes()
{
std::ifstream file("file.bin",std::ios_base::binary);
if(!file) std::abort();
std::vector<char> rawData(sizeof(Data));
file.read(rawData.data(),sizeof(Data));
if(!file) std::abort();
return rawData;
}
int main()
{
auto rawData=getDataBytes();
Data* data=magic_reinterpret(rawData.data());
std::cout << "someWord[346]=" << data->someWord[346] << "\n";
data->someDword[390875]=23235;
std::cout << "someDword=" << data->someDword << "\n";
}
现在magic_reinterpret这里实际上是坏的,因为它打破了严格的别名规则,从而导致UB.
它应该如何实现不会导致UB而不执行任何数据副本memcpy？
编辑: …
据我所知,在C++ 03中#include <cmath>必须只声明函数namespace std.从C++ 11开始,它们还可以在全局命名空间中声明.这是大多数C++实现在全局命名空间中声明函数(大概是#includeing <math.h>)的实践的结果,然后就是这样做using ::acos;了namespace std.
但在我看来,实现同样容易做到这样的事情<cmath>:
namespace __C_LANGUAGE_MATH_H
{
#include <math.h>
}
// ...
namespace std
{
// ...
using __C_LANGUAGE_MATH_H::acos;
// ...
}
为什么不实践而不仅仅是污染全局命名空间？我建议的解决方案是否有一些主要的缺点使得C++委员会允许在C++ 11中污染全局命名空间？
注意:这确实有效,并且链接器没有错误,至少使用GCC + Binutils-ld.我实际上尝试并编辑了GCC的cmath文件,如下所示,并编译了我的项目,它cmath成功地主动使用了函数(在修复了一些错误未std::在项目中指定的调用之后):
mv /usr/include/c++/5.3.0/cmath{,.bak}
sed -i -e 's@\(# *include <math.h>\)@namespace __C_LANGUAGE_MATH_H\n{\n\1\n}@' \
-e 's@\(using \+\)::@\1__C_LANGUAGE_MATH_H::@' /usr/include/c++/5.3.0/cmath
在eglibc中nptl/sysdeps/unix/sysv/linux/i386/fork.c有一个定义:
#define ARCH_FORK() \
INLINE_SYSCALL (clone, 5, \
CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID | SIGCHLD, 0, \
NULL, NULL, &THREAD_SELF->tid)
它在实际中__libc_fork()用作实现的核心.但是,例如在Linux中arch/x86/entry/syscalls/syscall_32.tbl存在一个sys_fork条目,以及在syscalls_64.tbl.显然Linux确实有其特殊的系统调用fork.
所以,我现在想知道:为什么glibc的实现fork()来讲clone,如果内核已经提供了fork系统调用？
我需要保存一个浮点值,它是一个整数值的复制内存.在reinterpretedFloat函数中,我创建了一个样本整数并将内存复制到float变量.事情是变化值当的memcpy-ED浮动收益.
这是示例代码.
#include <stdio.h>
#include <stdint.h>
void printHex(const unsigned char* buff, int count)
{
printf("0X");
for (int i = 0; i < count; ++i)
{
printf("\t%X", buff[i]);
}
printf("\n");
}
float reinterpretedFloat()
{
int32_t value = 0x7F845E58;
float tmp;
memcpy(&tmp, &value, sizeof(float));
printHex(reinterpret_cast<const unsigned char*>(&tmp), 4); //memcpy
return tmp;
}
int main()
{
float newFloat = reinterpretedFloat();
printHex(reinterpret_cast<const unsigned char*>(&newFloat), 4); //returned value
return 0;
}
这是结果.
0X 58 5E 84 7F(memcpy)
0X 58 5E C4 …从这个答案中，我了解到在C ++ 17中，我们可以std::fstream通过使用UTF-8路径打开std::filesystem::u8path。但是在C ++ 20中，不建议使用此函数，而应该将其传递const char8_t*给std::filesystem::path构造函数。
问题来了：尽管我们可以合法地（通过reinterpret_cast）将任何指针转换为const char*，但我们不能向后做：from const char*到eg const char8_t*（这会破坏严格的别名规则）。因此，如果我们有一些外部API返回char文件名的基于UTF-8的表示形式（例如，使用C语言编写的库），则无法安全地将指针转换为char8_t基于文件的指针。
那么，我们应该如何将这种char基于UTF-8字符串char8_t的视图转换为基于它们的UTF-8字符串？
考虑以下示例：
{
int x;
(void)x; // silence the "unused" warning
...
}
是否由于x未初始化读取而导致未定义行为？如果是，那么这是否意味着在以下代码中，编译器必须发出内存读取指令（以读取指针）？
volatile char* p=getP();
(void)*p;
我对这方面的C和C ++规则都感兴趣，以防它们有所不同。
一个什么都不做的虚拟析构函数
virtual ~ClassName() {}
从C++ 11开始,我们可以说:
virtual ~ClassName() = default;
这两者有什么区别吗？