标签: c++98

有没有一个很好的理由为什么这个程序在GCC下编译,即使使用-ansi和-pedantic标志？

#include <cmath>

int main (int argc, char *argv [])
{
     double x = 0.5;

     return static_cast<int>(round(x));
}

用它来编译干净(没有警告,甚至)g++ -ansi -pedantic -Wall test.cpp -o test.

我看到两个问题:

1. round() 在ISO-conformant模式下不应该对C++可用(因为它来自C99)
2. 即使round()在这种情况下可用,它也应该只是std命名空间

我错了吗？

我在"Foo"类(下面)中定义了一组枚举值.

namespace Fii
{
    class Foo 
    {
        struct Bar
        {
            enum Baz
            {
                BAZ1,
                BAZ2, 
                BAZ3
            };
        };
    };
};

我使用结构来减少Baz枚举值的范围,并显示有一组相关的值.

我的目标是将枚举类型的值赋给变量.使用上面的类定义,可以这样做:

Fii::Foo::Bar::Baz myValue = Fii::Foo::Bar::BAZ1 (Works in both C++98 and C++11)

但是,我觉得:

• 乍一看,myValue似乎被初始化为Fii :: Foo :: Bar,但这只是因为枚举是一个hack来对父节点中的相关常量进行分组(在这种情况下为Bar)

为了提高准备程度,我将代码重新考虑为:

namespace Fii
{
    class Foo 
    {
        enum Baz
        {
            BAZ1,
            BAZ2, 
            BAZ3
        };
    };
};

使用这个新的类定义,可以这样做:

Fii::Foo::Baz myValue = Fii::Foo::Baz::BAZ1 (Works in C++11 only)
Fii::Foo::Baz myValue = Fii::Foo::BAZ1 (Should work on C++98 and C++11 - …

我有以下代码将vectorOfInterest拆分为较小的块以发送出去.这段代码正在运行.

但是,当我将vectorOfInterest拆分为较小的块(在subList和其余的构造函数中)时,我会复制一份.是否有更好的使用移动而不是再次复制数据以获得更好的性能？

请注意,我无法更改OTHERCLASS :: doSend()的参数

编辑:我正在使用C++ 98

int blockSize = 50;
vector <CLASS_T> vectorOfInterest; 

// ...<populates vectorOfInterest>
do {
    if(vectorOfInterest.size()> blockSize)
        vector<CLASS_T>iterator from = vectorOfInterest.begin();
        vector<CLASS_T>iterator to = from + blockSize;

        //elements are copied again in subList and remainder
        //I like to move the elements from vectorOfInterest instead.
        vector<CLASS_T> subList (from, to);  
        vector<CLASS_T> remainder (to, vectorOfInterest.end());
        vectorOfInterest.swap(remainder);

        OTHERCLASS::doSend (subList); // method which sends sublists in blocks of exactly 50 to external library
    }else {
        //pad to exactly size 50 
        vectorOfInterest.resize(blockSize); …

在大量使用 Haskell 和函数式语言之后，我开始学习 C++，我发现我一直在尝试解决同样的问题：

• 从输入流中读取一些数据
• 根据特定算法对它们进行标记
• 处理令牌

如果这是 Haskell，我可以简单地利用一切都是懒惰的事实，并在我想到的时候编写我的转换，然后它会在下游被消耗时应用。甚至有一些库可以执行这种精确的模式（导管和管道）。

假设我想获取序列1 2 3 4 5 6 ...和输出12 34 56 ...。我可以了解如何编写在流上运行并就地处理数据的临时代码。但我想知道是否存在一种抽象机制，允许我通过转换来自另一个流的数据（以任何可以想到的方式）来构建新的流。这种抽象应该允许我在处理数据时缓冲数据，而不仅仅是单个元素到新值的简单映射。

以下是限制：

• 除了 stdlib 之外，我无法使用任何其他库。
• 它必须适用于 C++03（意味着没有 C++11 功能。）

如果你在想，这是作业吗？好吧，我收到了很多类作业，这些作业要求我处理数据流（这就是没有库和 C++03 限制的原因）。并不是我不知道如何使用while循环来做到这一点，而是我想知道 stl 中是否存在现有的流抽象，只是等待被发现和使用。

但如果唯一的方法是使用 C++11，那么我想知道。

我有与此等效的代码：

class X {};
class Y {};

template< typename T>
  class C {
  public:
      virtual  T * foo() = 0;
  };

class A : public C< X> {
public:
    X * foo() {};
};

class B : public A {};

class D : public B, public C< Y> {
public:
    Y * foo() {}; //this is the only one method I need here. Not A::foo!
};

我收到这个错误：

error:   invalid covariant return type for 'virtual Y* D::foo()'
 Y * foo() {}; …

#include <string>
#include <iostream>

int main() {
    std::string s = "abcdef";

    std::string s2 = s;

    auto begin = const_cast<std::string const &>(s2).begin();
    auto end = s2.end();

    std::cout << end - begin << '\n';
}

此代码将结果begin() const与结果混合end().这些函数都不允许使任何迭代器无效.但是我很好奇是否要求end()使iterator变量无效begin实际意味着该变量begin是可用的end.

考虑一个C++ 98,写时复制的实现std::string; 非const begin()和end()函数会导致复制内部缓冲区,因为这些函数的结果可用于修改字符串.所以begin上面开始时都有效s和s2,而是使用非const的end()构件使之不再有效s2,产生它的容器.

上面的代码通过copy-on-write实现产生"意外"结果,例如libstdc ++.libstdc ++ 不是end - begin相同s2.size(),而是产生另一个数字.

• 是否导致begin …

我需要一个“随机”数字生成器，对于Windows，Mac，Linux，iOS和Android上的给定种子，其生成的结果相同。现在我想std::rand和boost::random_int_generator同boost::mt19937，但遗憾的是，结果是Windows和Mac之间的不同。

有谁知道在所有平台上都能可靠运行的（C ++）实现吗？

编辑1：

更具体地说，boost::mt19937在Windows和Mac上的数字之间存在差异，这表明在Windows上还会生成（2）个其他数字块。看起来真的很奇怪，因为大多数数字都是相同的，这些块仅出现在Windows上。

编辑2：

boost::mt19937在所有平台上都能可靠运行。我们的问题不是那里的错误。

C++11引入了nullptr我没有的关键字。

我想有NULL来自 C的宏，我从这里和这里的一些东西中读到了在 C++ 中使用的宏，但我仍然不确定在这个旧的 C++ 标准中检查空指针的正确方法是什么。

我基本上希望能够使用 Boost Test 为我的测试用例编写此代码：

aWrapperDataStructure x;
BOOST_CHECK_NE(x.get_ptr(), static_cast<decltype(x.get_ptr())>(nullptr));

但也许，正如 Tutorials Point 建议的那样，考虑到限制，这样的事情更合适：

BOOST_CHECK(x.get_ptr()); //true when not NULL

不过，关于这方面的一些事情让我感到厌烦，所以我想知道这里的最佳做法是什么。如果它在网上的某个地方，或者在 SO 上，它已经被埋藏很久了，我找不到它。谢谢！

我的 C++ 编译器标识是 GNU 4.4.1

我认为从 c++ 11 开始，您可以通过以下方式初始化向量：

const std::vector<int> myVector = {1, 2, 3};
const std::vector<int> myVector2{1, 2, 3};

不幸的是，我没有使用 c++ 11，所以 myVector 只能由构造函数初始化。我需要创建一个永远不会被修改的向量。它必须由类中的不同函数共享，因此它也可以是静态的，甚至是类成员。有没有办法让我的向量在 c++98 中定义时被初始化，如上面的例子，或者等价的东西？

类似的代码例如(a+=1)%=7;，其中 a 是一个int变量。

我们知道运算符+=or=不是序列点，因此我们在两个相邻的序列点之间有两个副作用。（我们这里使用的是cpp98的序列点规则）

然而，赋值运算符喜欢+=或=保证在赋值后返回左值，这意味着执行顺序在某种程度上是“定义的”。

那么这是一种未定义的行为吗？