标签: c++98

任何想法为什么virtual~exception()throw()在C++ 98中,但virtual~exception()在C++ 11中？

什么是允许C++ 11投入类的析构函数的设计决策exception？

从这里:

C++ 98:

class exception {
public:
  exception () throw();
  exception (const exception&) throw();
  exception& operator= (const exception&) throw();
  virtual ~exception() throw();
  virtual const char* what() const throw();
}

C++ 11:

class exception {
public:
  exception () noexcept;
  exception (const exception&) noexcept;
  exception& operator= (const exception&) noexcept;
  virtual ~exception();
  virtual const char* what() const noexcept;
}

该constexpr关键字是在C++ 11中引入的,因为(我认为)是"常量表达式"的相应概念.但是,这个概念隐含在C++ 98/c ++ 03中,因为数组声明需要一个常量表达式:

// valid:
int a[sizeof(int)];
int b[3+7];
int c[13/4];
const int n = 3;
int d[n];
// invalid:
int m = 4;
int e[m];

还有其他"常量表达式",即可以在编译时评估(和/或必须)的表达式; 一个例子是模板参数.

对于预C++ 11,在C++ 98/03标准或其他地方是否存在以下情况？

• 需要常量表达式的语法结构的完整列表(例如数组声明和模板实例化)
• 管理这种常量表达式的规则(可能这只是从上面列表中的项到它们在标准中的定义的映射)

这编译:

std::vector<int> value = boost::assign::list_of(1)(2);

但不是这个:

Constructor(std::vector<int> value)
{
}

Constructor (boost::assign::list_of(1)(2));

是否有一个单线程解决方案来初始化传递给构造函数的向量？

更好的是,如果构造函数通过引用而复制到类变量:

Constructor(std::vector<int>& value)
{
    _value = value;
}

UPDATE

如果我尝试以下方法:

enum Foo
{
    FOO_ONE, FOO_TWO 
};

class Constructor
{
public:
    Constructor(const std::vector<Foo>& value){}
};

Constructor c(std::vector<Foo>(boost::assign::list_of(FOO_ONE)));

我收到编译器错误:

error C2440: '<function-style-cast>' : cannot convert from 'boost::assign_detail::generic_list<T>' to 'std::vector<_Ty>'
1>          with
1>          [
1>              T=Foo
1>          ]
1>          and
1>          [
1>              _Ty=Foo
1>          ]
1>          No constructor could take the source type, or constructor overload resolution was ambiguous

假设我正在使用一个C API,它允许您注册带有void*闭包的回调:

void register_callback(void (*func)(void*), void *closure);

在C++中,拥有更强大的类型是很好的,void*所以我想创建一个包装器,让我注册强类型的C++回调:

template <typename T, void F(T*)>
void CallbackWrapper(void *p) {
  return F(static_cast<T*>(p));
}

void MyCallback(int* param) {}

void f(void *closure) {
  register_callback(CallbackWrapper<int, MyCallback>, closure);
}

这没关系.这个解决方案的一个很好的属性是它可以将我的回调内联到包装器中,所以这个包装方案没有开销.我认为这是一个要求.

但是如果我能让API看起来更像这样会很好:

void f2() {
  RegisterCallback(MyCallback, closure);
}

我希望通过推断模板参数来实现上述目的.但我无法弄清楚如何让它发挥作用.我到目前为止的尝试是:

template <typename T>
void RegisterCallback(void (*f)(T*), T* closure) {
  register_callback(CallbackWrapper<T, f>, closure);
}

但这不起作用.任何人都有一个神奇的咒语,可以使f2()上面的工作,同时保持零开销性能特征？我想要一些适用于C++ 98的东西.

干杯和hth.- Alf在这个答案中发表评论说,与C++ 98相比,值初始化可以说是C++ 03的一个新特性.我想知道他的意思.

是值初始化的C++ 98的一部分？它是出现在概念中而不是名义上吗？为什么它被添加到C++ 03标准中？

我有'03标准的副本,但不是'98标准.这是默认初始化和值初始化的定义.

默认初始化T类型的对象意味着:

- 如果T是非POD类类型(第9节),则调用T的默认构造函数(如果T没有可访问的默认构造函数,则初始化是错误的);

- 如果T是数组类型,则每个元素都是默认初始化的;

- 否则,对象被零初始化.

对值类型T的对象进行值初始化意味着:

- 如果T是具有用户声明的构造函数(12.1)的类类型(第9节),则调用T的默认构造函数(如果T没有可访问的默认构造函数,则初始化是错误的);

- 如果T是没有用户声明的构造函数的非联合类类型,则T的每个非静态数据成员和基类组件都是值初始化的;

- 如果T是数组类型,则每个元素都是值初始化的;

- 否则,对象被零初始化

我的猜测是'98有默认初始化但不是值初始化,并且两者之间存在一些关键差异.说实话,我在解析这里的标准时遇到了麻烦,我不明白这些定义之间的区别.

有没有办法在C++ 98中为以下行创建速记别名？

std::precision(3) << std::fixed

然后使用别名如下:

std::cout << alias << 3.1415926 << std::endl;

我必须使用以下规则构造一个有序容器(必须是可迭代的):

如果条件为真,则容器是{1,0},否则就是{0,1}

我有以下代码,但我发现它并不"优雅":

   vector<int> orderedSides;
   if (condition) 
   {
       orderedSides.push_back(1);
       orderedSides.push_back(0);
   }
   else            
   {
       orderedSides.push_back(0);
       orderedSides.push_back(1);
   }

有没有更好的方法(从简洁和性能的角度来看)？

我有人告诉我,C++ 98是在ANSI正式标准化为ISO/IEC 14882:1998之前用ANSI编写的.

我知道ANSI与C有关,但我似乎找不到很多证明"ANSI C++"这个短语非常准确的证据.

• "ANSI C++"对C++ 98来说是一个很好的描述吗？
• "ANSI C++"对C++标准的后续版本是一个很好的描述吗？

我有一对矢量.该对中的第一个是std :: string类型,第二个是Container类型.

std或boost中存在哪些方便的功能,以便在给定字符串值作为键的情况下返回Container？

UPDATE

有人评论说我可以使用std :: map,但实际上我需要保留我的项目的顺序,按照我将它们推送到向量的顺序.

我收到此代码的编译器错误:

#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>

struct Name
{
};
typedef boost::shared_ptr<Name> NamePtr;

struct Foo
{
    NamePtr name;
};
typedef boost::shared_ptr<Foo> FooPtr;

template<class T>
void setName(T item, NamePtr name = boost::make_shared<Name>() )
{
    item->name = name;  
}

int main()
{
    FooPtr foo = boost::make_shared<Foo>();
    setName(foo);
    return 0;
}

如下:

    main.cpp: error C2780: 'boost::shared_ptr<X> boost::make_shared(A1 &&,A2 &&,A3 &&,A4 &&,A5 &&,A6 &&,A7 &&,A8 &&,A9 &&)' : expects 9 arguments - 0 provided
1>          c:\users\ebargri\desktop\boost_1_49_0\boost\smart_ptr\make_shared.hpp(590) : see declaration of 'boost::make_shared'
1>main.cpp: error C2780: 'boost::shared_ptr<X> …