我尝试在编码中播放音乐文件,但失败了.我将我的音乐文件放在保存.cpp文件的同一文件夹中.
有人能帮我吗？
我的代码是:
#include <iostream>
#include <windows.h>
int main() {
PlaySound("kenny g.WAV", NULL, SND_ASYNC);
}
在确定以下两段代码的命中率和未命中率时遇到一些麻烦.
给定信息:我们有一个1024字节的直接映射缓存,块大小为16字节.这样就可以生成64行(在这种情况下设置).假设缓存开始为空.请考虑以下代码:
struct pos {
int x;
int y;
};
struct pos grid[16][16];
int total_x = 0; int total_y = 0;
void function1() {
int i, j;
for (i = 0; i < 16; i++) {
for (j = 0; j < 16; j++) {
total_x += grid[j][i].x;
total_y += grid[j][i].y;
}
}
}
void function2() {
int i, j;
for (i = 0; i < 16; i++) {
for (j = 0; j < 16; j++) {
total_x += …有没有办法静态迭代C++结构的所有成员？
假如我们有许多预定义的结构,如下所示:
struct Foo {
int field1;
double field2;
char field3;
...
int field9;
};
struct Bar {
double field14;
char field15;
int field16;
bool field17;
...
double field23;
};
我们想要一个模板功能
template<typename T>
void Iterate(T object);
这样就Iterate可以Add在所有类型的成员上运行模板功能T.例如,Iterate<Foo>并且Iterate<Bar>将成为
void Iterate<Foo>(Foo object) {
Add<int>(object.field1);
Add<double>(object.field2);
Add<char>(object.field3);
...
Add<int>(object.field9);
}
void Iterate<Bar>(Bar object) {
Add<double>(object.field14);
Add<char>(object.field15);
Add<int>(object.field16);
Add<bool>(object.field17);
...
Add<double>(object.field23);
}
这可以通过编写另一个解析struct定义并生成cpp文件的程序来完成,但这样做太麻烦,需要额外的编译和执行.
编辑:结构可能有许多字段,它们是预定义的,因此不能更改为其他类型.这也是在编译时,所以它与"反射"关系不大,"反射"是在运行时执行的,更多地与"模板编程"或"元编程"有关.我们<type_traits>在编译时进行类型检查,但这似乎不够.
如果我定义一个函数:
fn f() -> Result<(), E> {
// How to return Ok()?
}
我怎样才能返回Ok在std::result与单位类型()？
当我运行这个类时,for循环似乎提前终止
class Test {
public static void main(String[] args) {
int result = 0;
int end = Integer.MAX_VALUE;
int i;
for (i = 1; i <= end; i += 2) {
System.out.println(i);
}
System.out.println("End:" + i);
}
}
输出是:
1
3
5
...
31173
31175
End:31177
为什么它会在那里结束？有趣的是,如果我System.out.println(i)在for循环中删除了,那么输出就是End:-2147483647.显然,值i了wrapped round.
我正在使用的Java版本是
Java(TM) SE Runtime Environment (build 1.6.0_16-b01)
Java HotSpot(TM) 64-Bit Server VM (build 14.2-b01, mixed mode)
我正在使用a SynchronisedQueue来进行线程之间的通信.我发现当附加线程在条件变量上等待时销毁线程对象会导致程序崩溃.这可以通过detach()在线程销毁之前调用来纠正.但我想知道等待条件变量的线程终止后会发生什么.有没有其他方法可以使用条件变量来避免这种情况？
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
template <typename Type> class SynchronisedQueue {
public:
void Enqueue(Type const & data) {
std::unique_lock<std::mutex> lock(mutex_);
queue_.push(data);
condition_.notify_one();
}
Type Dequeue() {
std::unique_lock<std::mutex> lock(mutex_);
while (queue_.empty())
condition_.wait(lock);
Type result = queue_.front();
queue_.pop();
return result;
}
private:
std::queue<Type> queue_;
std::mutex mutex_;
std::condition_variable condition_;
};
class Worker {
public:
Worker(SynchronisedQueue<int> * queue) : queue_(queue) {}
void operator()() {
queue_->Dequeue(); // <-- The thread waits here.
}
private:
SynchronisedQueue<int> * queue_; …我在哪里可以sbrk()详细了解一下？
它是如何工作的？
在什么情况下我会想使用sbrk(),而不是繁琐的malloc()和new()？
顺便问一下,扩展是sbrk()什么？
我一直在研究Linux中的信号.我已经完成了一个捕获SIGINT的测试程序.
#include <unistd.h>
#include <signal.h>
#include <iostream>
void signal_handler(int signal_no);
int main() {
signal(SIGINT, signal_handler);
for (int i = 0; i < 10; ++i) {
std::cout << "I'm sleeping..." << std::endl;
unsigned int one_ms = 1000;
usleep(200* one_ms);
}
return 0;
}
void signal_handler(int signal_no) {
if (signal_no == SIGINT)
std::cout << "Oops, you pressed Ctrl+C!\n";
return;
}
输出看起来像这样:
I'm sleeping...
I'm sleeping...
^COops, you pressed Ctrl+C!
I'm sleeping...
I'm sleeping...
^COops, you pressed Ctrl+C!
I'm sleeping...
^COops, you pressed …Unix内核表示使用三个数据结构打开的文件:Descriptor table,File table,和v-node table.
当一个进程打开一个文件两次时,它会在descriptor table两个条目中得到两个不同的描述符file table(因此它们在同一个文件中有不同的位置),并且它们都指向一个条目v-node table.
并且子进程继承父进程descriptor table,因此内核descriptor table分别为每个进程维护一个进程.但是来自不同进程的两个描述符指向相同的条目open file table.
所以
fork一个文件上获得相同的效果？这意味着两个进程共享同一文件上的位置(偏移)信息.