小编Ale*_*zzi的帖子

三个不同的编译器显示编译此代码的三种不同行为:

class MyException : public std::exception
{
 public:
  MyException(std::string str) : m_str(str) {}
  virtual const char * what() const throw () {return m_str.c_str(); }
 protected:
  std::string m_str;
};

Sun C++ 5.8 Patch 121017-22 2010/09/29:警告函数MyException :: 〜MyException ()只能抛出函数std :: exception :: ~exception()抛出的异常它会覆盖

g ++ 3.4.3: `virtual MyException:~MyException()'的错误抛出说明符

Visual Studio 2005:非常高兴(既不是错误也不是警告)

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

我正在 cppreference 中查看这些相关的标准函数系列：std::round、std::floor和。std::ceilstd::trunc

有什么理由为什么std::round是唯一一个提供特定签名long并long long作为返回类型的吗？我正在努力思考除了历史之外的任何原因，但std::round最近才在 C++11 中添加了这一点。

背景

有一个复杂的系统,其中包含多个库和应用程序,几乎每个项目都依赖于定义枚举的头文件(例如foo.h)(#include在几个cpp文件中).设计远非理想(但通常它是遗留系统).

可悲的是,foo.h经常发生变化.

条件

假设我们可以保证foo.h将被更新:只在最后添加元素,而不删除现有值或重新定义它们.

问题

这种修改是否需要重新编译包含头文件的所有代码？我知道这是类的常见问题(通常删除未使用的变量会更改内存布局并最终导致核心转储).我怀疑这也可能与枚举类似,在正常情况下我肯定会重新编译所有内容.目前的情况在所有代码库中引入了一种刚性,这极大地影响了系统的发展方式.

我想知道我是否"必须"重新编译.此信息可用于设置重构策略.

注意

我看过这个问题,但我认为它实际上并没有回答我的问题.

我在实现运算符时遇到问题!=在一个派生类中派生出一个抽象的类.代码如下所示:

class Abstract
{
  public:
     //to make the syntax easier let's use a raw pointer
     virtual bool operator!=(const Abstract* other) = 0;
};

class Implementation
{
    SomeObject impl_; //that already implement the operator!=
  public:
    bool operator!=(const Abstract* other)
    {
      return dynamic_cast<Implementation*>(other)->impl_ != this->impl_;
    }
};

这段代码有效,但它有使用dynamic_cast的缺点,我需要处理转换操作中的错误.

这是一个泛型问题,当它试图使用某些内部信息(在抽象类级别不可用)执行任务的具体类的函数时发生.

有没有更好的方法来解决这类问题？

干杯

我有一组与一对一关系相关的类型,例如:

TypeA ---> Type1
TypeB ---> Type2 
TypeC ---> Type3

我在编译时就知道这些关系.

然后,我有一个依赖于这两种类型的模板类:

template<class T1,class T2>
class MyClass
{
  T1 foo;
  T2 bar;
};

现在,我的库的用户将键入以下内容:

MyClass<TypeA,Type1> x;

这是不方便的,因为两种类型之间存在依赖关系,并且应该足以让用户仅指定第一种类型.

此外,不应该混合这两种类型:

MyClass<TypeA,Type2> y; //it should not compile

我对模板元编程不是很熟悉,我觉得这是可行的任务,但我可能错了.

涉及的类型数量很大,但是我很乐意在必要时运行脚本来生成代码.

你知道是否有可能或者我在浪费时间吗？你有什么想法让我指出正确的方向吗？

请参阅此网站http://www.cplusplus.com/reference/std/utility/make_pair/

std :: make_pair具有此签名(以及可能的实现):

template <class T1,class T2>
pair<T1,T2> make_pair (T1 x, T2 y)
{
    return ( pair<T1,T2>(x,y) );
}

我想知道为什么std :: make_pair有值输入参数而不是const引用？

这有什么特别的原因吗？

我正在实施(用于培训目的)冒泡排序模板功能:

template<typename iterInput,
         typename predicate>
void BubbleSort(iterInput first1,iterInput last1,predicate func)
{
    bool swapped(false);
    do
    {
        swapped = false;
        iterInput begin = first1;
        iterInput beginMinus = first1;
        ++begin;
        for (;begin != last1; begin++,beginMinus++)
        {
            if (func(*beginMinus,*begin) )
            {
                std::swap(*beginMinus,*begin);
                swapped = true;
            }
        }
    }
    while(swapped);
}

当我意识到这个函数不适用于没有赋值运算符的类,就像这个(原谅我的坏名字):

class NoCopyable
{
public:
    explicit NoCopyable(int value) : value_(value) {}
    NoCopyable(const NoCopyable& other) : value_(other.value_) {}
    ~NoCopyable() {}
    bool operator<(const NoCopyable& other) { return value_ < other.value_; }
    void setValue(int value) { value_ …

我认为,使用示例更容易解释.让我们来一个模拟一级方程式赛车速度的课程,界面可能如下所示:

class SpeedF1
{
public:
  explicit SpeedF1(double speed);
  double getSpeed() const;
  void setSpeed(double newSpeed);
  //other stuff as unit 
private:
  double speed_;
};

现在,负速度在这种特殊情况下没有意义,也没有超过500 km/h的值.在这种情况下,如果提供的值不在逻辑范围内,则构造函数和setSpeed函数可能会抛出异常.

我可以引入一个额外的抽象层并插入一个额外的对象而不是double.新对象将是double的包装器,它将构造并永不修改.该类的接口将更改为:

class ReasonableSpeed
{
public:
  explicit ReasonableSpeed(double speed); //may throw a logic error
  double getSpeed() const;
  //no setter are provide
private:
  double speed_;
};

class SpeedF1
{
public:
  explicit SpeedF1(const ReasonableSpeed& speed);
  ReasonableSpeed getSpeed() const;
  void setSpeed(const ReasonableSpeed& newSpeed);
  //other stuff as unit 
private:
  ReasonableSpeed speed_;
};

使用这种设计SpeedF1不能抛出,但是每次我想重置速度时我需要额外支付一个对象构造函数.

对于有限的一组值是合理的类(例如日历中的月),我通常将构造函数设为私有,并提供一组完整的静态函数.在这种情况下,这是不可能的,另一种可能性是实现一个空对象模式,但我不确定它是否优于简单抛出异常.

最后,我的问题是:

解决此类问题的最佳做法是什么？

我正在使用Eclipse IDE和tomcat 7.0

我有一个客户端 - 服务器应用程序.在服务器端,我有一个实现StationInterface和Serializable的StationInterface和Station类,我也在服务器端使用AOP来记录Station中的一些事件.现在,当我将对象发送到客户端时,我得到了这个异常

java.io.WriteAbortedException: writing aborted; java.io.NotSerializableException: org.springframework.aop.aspectj.annotation.InstantiationModelAwarePointcutAdvisorImpl
at java.io.ObjectInputStream.readObject0(Unknown Source)
at java.io.ObjectInputStream.readArray(Unknown Source)
at java.io.ObjectInputStream.readObject0(Unknown Source)
at java.io.ObjectInputStream.defaultReadFields(Unknown Source)
at java.io.ObjectInputStream.readSerialData(Unknown Source)
at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source)
at java.io.ObjectInputStream.readObject0(Unknown Source)
at java.io.ObjectInputStream.defaultReadFields(Unknown Source)
at java.io.ObjectInputStream.readSerialData(Unknown Source)
at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source)
at java.io.ObjectInputStream.readObject0(Unknown Source)
at java.io.ObjectInputStream.defaultReadFields(Unknown Source)
at java.io.ObjectInputStream.readSerialData(Unknown Source)
at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source)
at java.io.ObjectInputStream.readObject0(Unknown Source)
at java.io.ObjectInputStream.defaultReadFields(Unknown Source)
at java.io.ObjectInputStream.readSerialData(Unknown Source)
at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source)
at java.io.ObjectInputStream.readObject0(Unknown Source)
at java.io.ObjectInputStream.readArray(Unknown Source)
at java.io.ObjectInputStream.readObject0(Unknown Source)
at java.io.ObjectInputStream.defaultReadFields(Unknown Source)
at java.io.ObjectInputStream.readSerialData(Unknown Source) …

这个问题听起来有点不同寻常.我们来看一个POD结构:

struct MyStruct
{
   int myInt;
   double myDouble;
   AnotherPOD* myPointer;
};

编译器知道可用数据成员的列表.您是否知道在编译时(更好)或运行时获取数据成员名称列表(和类型)的方法？

我有大量的POD结构,我想自动创建operator <<.

我知道我可以为头文件创建一个解析器,创建一些文件并编译它们.但是,我确信编译器已经有了这些信息,我想利用它.

有任何想法吗？

谢谢