假设我有以下代码:
struct mytype
{
~mytype() { /* do something like call Mix_CloseAudio etc */ }
};
int main()
{
mytype instant;
init_stuff();
start();
return 0;
}
即使从start()内部的某个地方使用exit(),是否可以保证调用析构函数？
这是我正在使用的:
class something
{
char flags[26][80];
} a;
std::fill(&a.flags[0][0], &a.flags[0][0]+26*80, 0);
(更新:我之前应该已经明确表示我正在课堂上使用它.)
在Youtube上的GoogleTechTalks视频中,Bjarne Stroustrup谈到即将推出的C++ 0x标准.在视频中,他提到了以下示例:
#include <iostream>
struct Sick
{
Sick(double d) { std::cout << d << "\n"; }
explicit Sick(int i) { std::cout << i << "\n"; }
};
int main()
{
Sick s1 = 2.1;
Sick s2(2.1);
}
他是否意味着将explicit关键字放在之前Sick(double)而不是Sick(int),以突出显示与某些上下文中的隐式转换相关的问题？
以下代码是否安全？(我已经知道它编译正确了.)
void Tile::clear()
{
*this = Tile();
}
int main()
{
Tile mytile;
mytile.clear();
}
以下看起来很合理，但我听说即使在 close() 调用之后，理论上数据仍然可以在缓冲区中而不是在磁盘上。
#include <fstream>
int main()
{
ofstream fsi("test.txt");
fsi << "Hello World";
fsi.flush();
fsi.close();
return 0;
}
在下面的示例中,std :: map结构填充了来自A - Z(对于键)的26个值和对于值的0 - 26.(在我的系统上)查找最后一个条目(10000000次)的时间对于向量大约为250毫秒,对于映射大约为125毫秒.(我使用发布模式编译,为g ++ 4.4启用了O3选项)
但是,如果由于一些奇怪的原因我想要比std :: map更好的性能,我需要考虑使用哪些数据结构和函数？
如果答案对您来说显而易见,我深表歉意,但我对C++编程的性能关键方面没有太多经验.
#include <ctime>
#include <map>
#include <vector>
#include <iostream>
struct mystruct
{
char key;
int value;
mystruct(char k = 0, int v = 0) : key(k), value(v) { }
};
int find(const std::vector<mystruct>& ref, char key)
{
for (std::vector<mystruct>::const_iterator i = ref.begin(); i != ref.end(); ++i)
if (i->key == key) return i->value;
return -1;
}
int main()
{
std::map<char, int> mymap;
std::vector<mystruct> myvec;
for (int i = 'a'; …将数据发送到fstream时检查一般错误的正确方法是什么？
更新：我主要关心的是我听到的一些有关输出与物理写入硬盘之间的延迟的信息。我的假设是命令“ save_file_obj << save_str”仅将数据发送到某种缓冲区，并且以下检查“ if（save_file_obj.bad（））”将不会用于确定是否存在操作系统或硬件问题。我只是想知道在执行以下任何操作（如关闭程序）之前，将字符串发送到文件并检查以确保将其写入磁盘的确定的“全部捕获”方法是什么。
我有以下代码...
int Saver::output()
{
save_file_handle.open(file_name.c_str());
if (save_file_handle.is_open())
{
save_file_handle << save_str.c_str();
if (save_file_handle.bad())
{
x_message("Error - failed to save file");
return 0;
}
save_file_handle.close();
if (save_file_handle.bad())
{
x_message("Error - failed to save file");
return 0;
}
return 1;
}
else
{
x_message("Error - couldn't open save file");
return 0;
}
}
以下比较是原子动作吗？即,它可以简化为单个CPU指令吗？
char flag = 2;
for(;;)
{
if (!flag) // <-- this
break;
// sleep
}
这是我正在做的事情:
int main()
{
sf::Mutex Mutex;
char flag = 2;
coordinatorFunction(flag);
for(;;)
{
if (!flag)
break;
// sleep
}
}
void workerFunction(void* a)
{
char* p = static_cast<char*>(a);
// work
GlobalMutex.Lock();
--*p;
GlobalMutex.Unlock();
}
void coordinatorFunction(char& refFlag)
{
sf::Thread worker1(&workerFunction, &refFlag);
sf::Thread worker2(&workerFunction, &refFlag);
worker1.Launch();
worker2.Launch();
}
以下是安全的吗？我知道,严格来说,在指向它的东西之前解除引用指针似乎很危险,但我想编译器只提供一个指针而不实际进行任何解除引用.好吧,我想.
(注意:gInst实际上直到很久才会使用该引用.)
TU 1
Sys::System::System::System(const sf::VideoMode& rVM, const std::string& rSTR, unsigned long settings) :
win(rVM, rSTR, settings),
gInst(*this)
{
}
标题A.
namespace Sys
{
namespace System
{
struct System;
}
namespace UI
{
struct GUI
{
System::System& topl;
MenuBar menu;
GUI(System::System&);
private:
GUI();
GUI(const GUI&);
GUI& operator=(const GUI&);
};
}
}
标题B
namespace Sys
{
namespace System
{
struct System
{
sf::RenderWindow win;
Sys::UI::GUI gInst;
Sys::Editor::Editor eInst;
System(const sf::VideoMode&, const std::string&, unsigned long);
private:
System();
System(const System&);
System& operator=(const System&); …拿这个代码:
struct mystruct
{
int var;
mystruct() : var(0) {}
};
int main()
{
mystruct ins;
int* p = &ins.var;
*p = 1;
}
那么什么是类成员指针使用的具体非常好的例子呢？
int X::*p = &X::data; /* p contains offset */
X object;
X *objptr = new X;
int i = object.*p;
int j = objptr->*p;