小编Mic*_*l D的帖子

struct SS {int a; int s;};

int main ()
{
   vector<SS> v;
   v.push_back(SS{1, 2});
}

可以编译代码而不会出现任何错误.但是,当在类中初始化struct时,我得到了编译错误.有人能解释一下吗？

struct SS {int a = 0; int s = 2;};

错误:

In function ‘int main()’:
error: no matching function for call to ‘SS::SS(<brace-enclosed initializer list>)’
     v.push_back(SS{1, 2});
                        ^
note: candidates are:
note: constexpr SS::SS()
 struct SS {int a = 0; int s = 2;};
        ^
note:   candidate expects 0 arguments, 2 provided
note: constexpr SS::SS(const SS&)
note:   candidate expects 1 argument, 2 provided
note: …

可变参数模板在c ++ 11中引入.我发现可以使用它替换printf函数.但是,cout用于实现.我想知道是否有可能使用其他东西来实现类型安全但不牺牲太多性能.

void safe_printf(const char *s)
{
    while (*s) {
        if (*s == '%') {
            if (*(s + 1) == '%') {
                ++s;
            }
            else {
                throw "invalid format string: missing arguments";
            }
        }
        std::cout << *s++;
    }
}

template<typename T, typename... Args>
void safe_printf(const char *s, T& value, Args... args)
{
    while (*s) {
        if (*s == '%') {
            if (*(s + 1) == '%') {
                ++s;
            }
            else {
                std::cout << value;
                safe_printf(s + 1, args...); // …

我在互斥析构函数中得到了标题错误.由于错误可能是由于互斥锁在破坏期间处于锁定状态,因此我创建了一个新的互斥类,它继承自boost:mutex.这是为了确保在销毁期间互斥锁被解锁.但是,仍然会出现相同的错误.任何点击将不胜感激!

class CMutes : public boost::mutex
{
public:
    CMutes()
    {

    };

    virtual ~CMutes()
    {
        if (m_bLock)
            boost::mutex::unlock();
    };

    void lock()
    {
        if(!m_bLock)
            boost::mutex::lock();
        else
            cout << "Mutex is in lock state\n";
    };

    void unlock()
    {
        if (m_bLock)
            boost::mutex::unlock();
        else
            cout << "Mutex is in unlock state\n";
    }

    boost::mutex& getMutex()
    {
        return *this;
    }

private:

    bool m_bLock;
};

编辑:是的你是对的.我应该使用RAII.但是,我处于这种情况.我需要在另一个线程完成处理之前锁定资源.类似下面的东西.

Thread A:
void getDate()
{
 m_oLock.lock();
 // access resource
}

void unlock()
{
 m_oLock.unlock();
}
Thread B:
void Process()
{
 threadA.getData();
 threadA.unlock(); …

由于-fstack-protector-stronggcc中有一个选项可以检测堆栈粉碎.但是,它无法始终检测到堆栈缓冲区溢出.对于第一个函数func,当我输入10个字符串更多字符串时,程序并不总是崩溃.我的问题是有一种方法来检测堆栈缓冲区溢出.

void func()
{
    char array[10];
    gets(array);
}

void func2()
{
    char buffer[10];
    int n = sprintf(buffer, "%s", "abcdefghpapeas");
    printf("aaaa [%d], [%s]\n", n, buffer);
}

int main ()
{
   func();
   func2();
}

程序中有一些固定大小的二进制缓冲区用于存储数据.memcpy用于将缓冲区从一个缓冲区复制到另一个缓冲区.由于源缓冲区可能大于目标缓冲区.如何检测是否存在缓冲区溢出？

有没有人使用zeromq实现了actor模型？性能如何？使用什么模式？REQ/REP,PUB/SUB或PUSH/PULL？

我确实使用了另一个名为theron的库.但由于上下文切换,性能不太好.

是否可以分享您的想法/设计？

我发现boost有一个叫做context的类,用于上下文切换,对吧？

我尝试谷歌它但没有找到任何文件或例子.我只是想知道是否有人可以提供一些信息.

C++ 11提供了返回当前时间的函数.但是,我找不到返回当天的功能.我用boost来做到这一点.

boost::gregorian::date TODAY = boost::gregorian::day_clock::local_day();

有没有办法用chrono实现相同的结果？

编辑:我想要的是使用time_point来表示当天.这意味着小时,分钟和秒均为零2013-07-31 00:00:00

由于链不会同时执行,因此strand和单线程之间的性能差异是什么？而且,锁定不需要保护post函数处理程序中的共享数据,对吗？

假设应用程序性能有几个作业,下面是一些示例代码.

strand.post(boost::bind(&onJob, this, job1));

void onJob(tJobType oType)
{
  if (oType == job1)
   // do something
  else if(oType == job2)
   // do something
}

编辑:我尝试测量帖子的延迟,并且调用onJob非常高.我想知道是否有任何方法可以减少它