指针的多态性/boost::shared_ptr

Polymorphism with pointers/boost::shared_ptr

本文关键字：shared ptr boost 多态性 指针      更新时间：2023-10-16

考虑下面c++中多态性的例子。对我来说，这是一个意想不到的行为，这可能是因为我仍然在Java中思考太多。我现在的问题是:我如何让指针示例调用更具体的方法。

#include <iostream>
#include <string.h>
#include <boost/tr1/memory.hpp>
class Image {
 public:
  Image(std::string className = "Image") 
      : className_(className)
    {}
  virtual ~Image() {}
  virtual std::string className() {
    return className_;
  }
 private:
  std::string className_;
};
class RightImage : public Image {
 public:
  RightImage()
      : Image("RightImage")
    {}
};
class Processor{
 public:
  void process(Image& image){
    std::cout << "Invoking process(Image& image) with image of type "" << image.className() << """ << std::endl;
  }
  void process(RightImage& rightImage){
    std::cout << "Invoking process(RightImage& rightImage) with rightImage of type "" << rightImage.className()  << """ << std::endl;
  }
  void process(Image* image){
    std::cout << "Invoking process(Image* image) with image of type "" << image->className() << """ << std::endl;
  }
  void process(RightImage* rightImage){
    std::cout << "Invoking process(RightImage* rightImage) with rightImage of type "" << rightImage->className()  << """ << std::endl;
  }
};
int main(int argc, char **argv) {
      std::tr1::shared_ptr<Image> rightImageSharedPtr(new RightImage());
      Image* rightImagePointer = new RightImage();
      RightImage rightImage;
      Processor processor;
      std::cout << "value:                   ";
      processor.process(rightImage);
      std::cout << "shared_ptr:              ";
      processor.process(*rightImageSharedPtr);
      std::cout << "old fashioned pointer 1: ";
      processor.process(*rightImagePointer);
      std::cout << "old fashioned pointer 2: ";
      processor.process(rightImagePointer);
}

程序的输出是:

value:调用进程(右timage &

shared_ptr:调用进程(Image&

老式指针1:调用进程(Image&

老式指针2:调用进程(Image* Image)的图像类型为" righttimage "

如何使最后三个例子也称为process(RightImage&)和process(RightImage*) ?

除了tokage建议的双调度之外，您还可以只有一个Process()函数，其基类引用作为参数，然后通过调用Process()函数内部基类的虚函数来使用多态性。

我想你需要双重调度/访客模式来解决你的问题。

接口下的图像类型信息仅在对象内部可用。因此，您需要调用图像对象上的虚拟方法来获取您的底层类型。

的例子:

class Image{
    virtual void process(Processor &processor)=0;
}
class RightImage{
    virtual void process(Processor &processor){
        processor.process(this);
    }
}
当然，您也可以在process()-Method中在图像类内部进行处理，但我怀疑您希望不同类型的处理器处理不同类型的图像。另一种选择——可能更简洁一点——是让处理器为单个处理步骤调用虚拟方法，这些步骤因图像类型而异。

重载是在函数参数的静态类型上解决的，因此您需要将变量声明为

  std::tr1::shared_ptr<RightImage> rightImageSharedPtr(new RightImage());
  RightImage* rightImagePointer = new RightImage();

另一种方法是在调用每个函数之前执行dynamic_cast，这是一种更复杂的方法。

相关文章：