标签: c++98

所以我知道在C++常量中,默认情况下获得的变量与变量不同.这就是我不能放的原因

int foo;

在一些标题中 - 链接器会正确地抱怨多个定义.OTOH,我可以写

const int bar = 42;

在标题中,编译器确保只有一个定义bar.

使用积分常量,很容易看出编译器如何处理这个 - 至少只要没有人获取地址bar或做一些其他有趣的事情,需要它为它分配存储).但是,如果有人怎么办？如果它不是一个整体但需要在运行时执行的代码呢？假设我将其放入标题中:

const std::string baz = "h2g2";

假设没有小的字符串优化,这需要在运行时分配动态内存,因此需要执行代码,地址需要存储在某处,等等.

我假设我最终会得到baz每个翻译单元的一个定义,只是编译器为其分配内部链接以防止链接器抱怨？或者我错过了什么？

注意:我对constexpr普通的旧C++常量不感兴趣,因为它们自80年代以来就存在并且在C++ 98中编纂.(但是,如果一个全面的答案将包括这一切如何融合在一起constexpr,我不会抱怨.)

我偶然发现了一些非常古老的代码,它有一个带有定义的复制赋值运算符的类,它将其参数作为const引用,但也不检查自赋值,所以基本上:

struct A
{
    int q;
    A(): q(3) {}

    A& operator=(const A& a)
    {
        q = a.q;
        return *this;
    }
};

当一个实例A被赋给自己时,这个赋值运算符的行为是什么？我认为这会导致问题,因为它"破坏"参数的常量,任何编译器都可以假设参数没有改变并基于此进行优化.

然而,clang和gcc都没有发出警告,程序运行正常.如果我q在赋值运算符中赋值之前显式将值更改为4,这也可以工作.

我查看了GCC STL(4.6.1)并看到std::copy()在内置__is_trivial()评估的情况下使用优化版本true.

由于std::copy()和std::reverse_copy()模板对于复制数组中的元素非常有用,我想使用它们.但是,我有一些类型(模板实例化的结果),它们是包含一些简单值,没有指针并且没有复制构造函数或赋值运算符的结构.

G ++足够聪明,可以发现我的类型实际上是微不足道的吗？在C++ 98中是否有任何方法可以确保STL实现知道我的类型是微不足道的？

我想在C++ 11中,使用is_trivial<>类型特征会变得很方便.这是正确的吗？

谢谢!

编辑:很抱歉这么晚,但这是一个非常简单的Type类的例子,这对GCC和llvm来说并不简单.有任何想法吗？

#include <iostream>

struct Spec;

template <typename TValue, typename TSpec>
class Type
{
public:
    TValue value;

    Type() : value(0) {}
};

int main()
{
    std::cerr << "__is_trivial(...) == "
              << __is_trivial(Type<char, Spec>) << '\n';                                                                                                                                                                                                                                    
    return 0;
} 

我目前正在阅读一本2000年写的c ++书,基本上就是使用c ++ 98.(如果我错了,请纠正我)

我的问题是,阅读像这样的c ++ 11书(http://rads.stackoverflow.com/amzn/click/0321563840),大多数用户建议,要求我已经读过一本c ++ 98书？

使用背部时是否需要保留内存:插入器？

d.reserve(s.size())
std::copy (s.begin(),s.end(),back_inserter(d));

我正在寻找一些不使用有关浮点类型实现的假设的东西,并且不使用C++ 11/C99方法.

以下代码是检查INF和NAN的可靠方法吗？如果没有,究竟会出现什么问题？

bool isfinite(double n)
{
    if(std::numeric_limits<double>::has_infinity)
    {
        double inf = std::numeric_limits<double>::infinity();
        if(std::memcmp(&n, &inf, sizeof(double)) == 0)
            return false;

        double neginf = -inf;
        if(std::memcmp(&n, &neginf, sizeof(double)) == 0)
            return false;
    }

    if(std::numeric_limits<double>::has_quiet_NaN)
    {
        double nan = std::numeric_limits<double>::quiet_NaN();
        if(std::memcmp(&n, &nan, sizeof(double)) == 0)
            return false;

        double negnan = -nan;
        if(std::memcmp(&n, &negnan, sizeof(double)) == 0)
            return false;
    }

    return true;
}

编辑:具体来说,我正在寻找一种在语言中实现这一目标的方法,而不是依赖于编译器内部函数,先验定义或其他库,如boost.

我有一种类型,可以定义为矢量向量的矢量...整数类型的向量.例:

std::vector<std::vector<std::vector<std::vector< std::vector<signed char> > > > > _data;

我正在寻找一种优雅的方法来确定更深层次的非空向量的数量.我可以使用像4这样的封装循环来做那个例子

for (it0 = data.cbegin() ; it0 != _data.cend() ; ++it0)
 for (it1 = *it0.cbegin() ; it1 != *it0.cend() ; ++it1)
   for (it2 = *it1.cbegin() ; it2 != *it1.cend() ; ++it2)
      for (it3 = *it2.cbegin() ; it3 != *it2.cend() ; ++it3)
          nonEmpty += (unsigned int) (*it3.empty());

但是,我如何创建一个模板(支持向量,列表或任何类型的容器共享相同的API)功能,以便为任何深度(超过4级)执行此操作？我认为递归是正确的方法,但不知道如何使用Template ...

欢迎提供所有帮助和建议,因为我非常确定有多种解决方案.

在Java中我们可以创建一个类

class Test {
    public synchronized void  fn1() {

    }

    public synchronized void  fn2() {

    }

    public synchronized void  fn3() {
        fn1(); // Calling another method
    }
}

在 C++ 中，如果我想模仿功能，一种方法是

class Test {
    private:
        mutex obj;
    public:
       void fn1(bool calledFromWithinClass = false) {
            if(calledFromWithinClass) 
                fn1Helper();
            else
                unique_lock<mutex> lock(obj);
                fn1Helper();
        }

       void fn2(bool calledFromWithinClass = false) {
            if(calledFromWithinClass) 
                fn2Helper();
            else
                unique_lock<mutex> lock(obj);
                fn2Helper();
        }

        void fn3(bool calledFromWithinClass = false) {
            if(calledFromWithinClass) 
                fn3Helper();
            else {
                unique_lock<mutex> lock(obj);
                fn3Helper();
            } 
        }
    private: …

所以我正在阅读关于lambda演算的模板元程序的实现,这是TMP图灵完备性的一个证明.

当我阅读源代码时,我偶然发现了一行(然后更多),如下所示:

template <int Name, typename Value, typename Env>
struct EnvLookup <Name, Binding<Name,Value,Env> > 
{
  Value typedef result ; // Line 84, what is this ?
} ;

我已经习惯了typedef Type Alias;,但Type typedef Alias;对我来说却很陌生.而且它仍然可以用g ++ 4.9.0编写好的版本-std=c++98.

我在Google上找不到关于这种语法的任何文档,也没有关于SO的文档.这是否符合标准？也许是一个g ++扩展？它会融合吗 ？

struct Data
{
 ...
 CRITICAL_SECTION valLock;
}    
std::map<int, Data> mp;
CRITICAL_SECTION mpLock;

我目前正在使用两个关键部分来确保该线程安全。

我必须锁定两者map并Data更新Data

//Lock mpLock
//Lock mp[key1].valLock
mp[key1].something = something_new;
//unlock mp[key1].valLock
//unlock mpLock

我研究了英特尔的并发哈希图，它不需要两个锁并在内部处理这个问题。如果我不想使用英特尔的tbb，还有其他方法吗？我只有支持。不过c++ 98可以使用。boost调查过boost::shared_mutex，但无法关联如何在当前场景中使用它。

编辑：容器上的锁真的需要吗？我不能用来Data::valLock读/写Data。任何插入mp都不会影响现有的迭代器，因此不需要锁。任何删除mp都会以 开头Data::valLock。这里可能会错过什么情况？

编辑2：

UpdateThread()
{
   //Lock mp[key].valLock
   mp[key].a = b;         //Line 1
   //unlock mp[key].valLock
}

ReadThread()
{
    //Lock mp[key].valLock
   something = mp[key].a;   //Line 2
   //unlock mp[key].valLock
}

所以我认为只有当第 1 行完成（或反之亦然）即已mp更新（以及地图内部结构）时，第 …