小编Gin*_*lus的帖子

Checkstyle将此代码报告为"双重检查锁定习语已损坏",但我认为我的代码实际上并未受到双重检查锁定问题的影响.

如果不存在具有该id的行,则该代码应该在数据库中创建一行.它在多线程环境中运行,我想避免主键存在的SQL异常.

伪代码:

private void createRow(int id) {
  Row row = dao().fetch(id);
  if (row == null) {
     synchronized (TestClass.class) {
        row = dao().fetch(id);
        if (row == null) {
           dao().create(id);
        }
     }
  }
}

我可以同意它看起来像双重检查锁定,但我没有使用静态变量,fetch()和create()中的代码可能太复杂,无法内联并使其无序.

我错了还是格式？:)

所以我看到很多文章现在声称在C++上双重检查锁定,通常用于防止多个线程尝试初始化一个懒惰的单例,被打破了.正常双重检查锁定代码如下所示:

class singleton {
private:
    singleton(); // private constructor so users must call instance()
    static boost::mutex _init_mutex;

public:
    static singleton & instance()
    {
        static singleton* instance;

        if(!instance)
        {
            boost::mutex::scoped_lock lock(_init_mutex);

            if(!instance)           
                instance = new singleton;
        }

        return *instance;
    }
};

问题显然是行分配实例 - 编译器可以自由分配对象,然后将指针分配给它,或者将指针设置为它将被分配的位置,然后分配它.后一种情况打破了这个习惯用法 - 一个线程可以分配内存并分配指针,但在它进入休眠状态之前不运行单例的构造函数 - 然后第二个线程将看到该实例不为null并尝试返回它,即使它尚未建成.

我看到了一个使用线程局部布尔值的建议并检查而不是instance.像这样的东西:

class singleton {
private:
    singleton(); // private constructor so users must call instance()
    static boost::mutex _init_mutex;
    static boost::thread_specific_ptr<int> _sync_check;

public:
    static singleton & instance()
    {
        static …

我试图使用%C++和fmod函数的运算符得到-1 modulo 1000000007的结果.
输出是-1,但是-1 modulo 1000000007==1000000006.

我做错了什么？

我正在尝试做一个我学校的旧项目,它涉及C++ 98中的元编程.我正在努力反对的部分是关于SFINAE.

主题说我应该operator<<通过使用这样的结构检查流对象和另一个对象之间是否有效:

template<typename Stream, typename Object>
struct IsPrintable;

它说我应该用"两个空引用"写一个奇怪的行,我想它应该是这样的:

sizeof(*(static_cast<Stream *>(NULL)) << *(static_cast<Object *>(NULL)))

它在支持运算符时有效,但在不支持时不运行.我无法弄清楚我失败的地方,这里是文件:

template<typename Flux, typename Object>                                                                                                                                                                                                       
struct IsPrintable
{
  typedef char yes[1];
  typedef char no[2];

  template<size_t N>
  struct Test
  {
    typedef size_t type;
  };  

  template<typename U>
  static yes &isPrintable(U * = 0); 

  template<typename>
  static no &isPrintable(...);

  static const bool value = sizeof(isPrintable<Test<sizeof(*(static_cast<Flux *>(NULL)) << *(static_cast<Object *>(NULL)))> >(0)) == sizeof(yes);

};

主题明确地说使用以size_t作为参数的类,并且isPrintable方法应该采用指向此类实例的NULL指针.另外,使用static_cast的丑陋表达式应该用于类型定义,我试图键入它但是编译器对我尖叫.

我不知道所有内容,因为我对此非常陌生,我知道有一些方法可以简化decltype操作符,但项目的目的是在C++ 98中完成,如果有的话,它可能很有用.我稍后会找到一些这种类型的代码.

在回答这个问题时,我编写了这个工作代码,包装函数在模板参数中传递:

template<typename Fn, Fn fn, typename... Args>
auto wrapper(Args... args)->decltype(fn(args...)){
    return fn(args...);
}
#define WRAPPER(FUNC) wrapper<decltype(&FUNC), &FUNC>

用法示例(我使用此代码进行测试):

int min(int a, int b){
    return (a<b)?a:b;
}

#include<iostream>
using std::cout;
int main(){
    cout<<WRAPPER(min)(10, 20)<<'\n';
}

两个人告诉我使用完美转发.当我问到如何做到这一点时,其中一个人将我重定向到这里.我读了问题,仔细阅读了最佳答案,并改为wrapper:

#include<utility>
template<typename Fn, Fn fn, typename... Args>
auto wrapper(Args&&... args)->decltype(fn(std::forward<Args...>(args...))){
    return fn(std::forward<Args...>(args...));
}

它编译,除非我尝试使用上面的示例代码检查它.我该如何修复代码？

http://rextester.com/YUIYI99787

传递未初始化的变量srand而不是结果是不错的主意time(NULL)？
它是一个#include和一个函数调用较少.

示例代码:

#include <stdlib.h>

int main(void) {
    {
        usigned seed; //uninitialized
        srand(seed);
    }
    //other code
    return 0;
}

代替

#include <stdlib.h>
#include <time.h>

int main(void) {
    srand(time(NULL));
    //other code
    return 0;
}

我正在查看我们的应用程序中的一些代码,我认为可能会遇到" 双重检查锁定 "的情况.我写了一些与我们的工作类似的示例代码.

任何人都可以看到这是如何经历双重检查锁定？或者这样安全吗？

class Foo {
    private Helper helper = null;
    public Helper getHelper() {
        Helper result;
        synchronized(this) {
            result = helper;
        }

        if (helper == null) {
            synchronized(this) {
                if (helper == null) {
                    helper = new Helper();
                }
            }
        }
        return helper;
    }
}

从wiki借来的基本代码.

我最初用Python创建了这个游戏,然后在一个学校项目中将它转换为C++.

问题是C++ std::list不允许我访问像Python的list那样的项(list[1]更多),访问列表中的列表项(list[2][5]).我无法找到一种有效的方法来做到这一点或替代可行的列表.

我这里有代码,程序列出3-100的所有素数.我的主要问题是该程序只打印出三个.我认为由于某种原因,它会离开循环或其他东西.我在for语句中放了一个中断,一旦发现数字不是素数就立即离开内部for循环,以便它可以打印出来.但是,它似乎没有起作用.

#include <iostream>
#include <conio.h>
#include <cmath>

using namespace std;

int main()
{
    bool prime = true;

    for (int x = 3; x <= 100; x++)
    {
        for (int y = 2; y <= (x - 1); y++)
        {
            if ((x % y) == 0)
                prime = false;
            break;
        }

        if (prime == true)
            cout<<x<<endl;
   }

    getche();
    return 0;
}

我有一个包含这样内容的文本文件:Bill, 89 Alex, 64 Dan, 29,它代表一些学生的名字和他们的笔记.
我想按笔记对它们进行升序排序,我的想法是为每个名称创建一个整数,例如:int dan = 29;所以我可以对它们进行排序,但我不知道如何从文本文件中为这些名称分配一个整数.
希望你能帮忙,因为这是我第一次制作一个更复杂的程序.谢谢!

我有一个代码，其中我想，让用户通过标准输入三个值，每种类型的float，Fraction或者int，所以我不能申请ast.literal_eval输入得到结果，我想要的。

我读到Eval 真的很危险，显示

• eval提供意见的人如何利用弱点，以及
• 一些如何使eval调用更安全的方法。

我应用了作者的建议并编写了此代码，替换了默认值eval：

import builtins

class DoubleUnderscoreInEval(ValueError):
    pass

def eval(expression, globals={}, locals=None):
    if '__' in expression:
        raise DoubleUnderscoreInEval('Using __ in eval is not allowed for safety reasons.')
    else:
        if '__builtins__' not in globals:
            globals['__builtins__']={}
        return builtins.eval(expression, globals, locals)

builtins.eval通过我的代码使用是否完全安全？
如果不是，我可以使eval调用完全安全吗？（鼓励绕过我的限制的字符串）
如果是，如何？如果不是，我可以用什么代替？

我是 Python 的初学者，所以鼓励任何告诉我如何改进我的代码的评论。

我在在线编译器中的整个代码

我在我的CF应用程序中使用了双重检查锁定的版本(在我知道双重检查锁定之前).

基本上,我检查一个物体的存在.如果它不存在,我锁定(通常使用命名锁),在我尝试创建对象之前,我再次检查是否存在.我认为这是一种简洁的方法来阻止创建多个对象并停止系统中的过度锁定.

这似乎有效,因为没有过多的锁定,并且不会创建对象重复项.但是,我最近了解到Double Checked Locking在Java中不起作用,我不知道的是CF是否适用,因为CF线程和锁与本机Java线程和锁不完全相同.