使用指针/ boost :: shared_ptr的多态性

Question

Consider the following example of polymorphism in C++. To me, this is unexpected behavior, which probably lies in the fact that I am still thinking too much in Java. The question to me is now: How do I get the pointer example to call the more specific method.

#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);
}

The output of that program is:

value: Invoking process(RightImage& rightImage) with rightImage of type "RightImage"

shared_ptr: Invoking process(Image& image) with image of type "RightImage"

old fashioned pointer 1: Invoking process(Image& image) with image of type "RightImage"

old fashioned pointer 2: Invoking process(Image* image) with image of type "RightImage"

How can I make the last three examples also call process(RightImage&) and process(RightImage*) ?

Answer 1

I think you want something like double dispatch/ Visitor Pattern to solve your problem.

The information which type your Image really is under the interface is only available inside the object. So you need to call a virtual method on the image object to get at your underlying type.

Example:

class Image{
    virtual void process(Processor &processor)=0;
}

class RightImage{
    virtual void process(Processor &processor){
        processor.process(this);
    }
}

Of course you also could do the processing inside the image class in the process()-Method, but I suspect you want different kinds of processors to work on different types of images. Another option - which is a bit cleaner maybe - is to have the processor call virtual methods for the single processing steps where they differ for the image types.

Answer 2

在tokage提出的双重调度旁边，你也可以只有一个Process（）函数，基类引用作为参数，然后通过在Process（）函数中调用基类的虚函数来使用多态。

Answer 3

Overloading is resolved on the static types of a function's arguments so you need to declare your variables as

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

The alternative is to perform a dynamic_cast before calling each function, which is just a more convoluted way of doing the same thing.