Question

通过在创建对象后重载函数，是否可以使类函数的行为完全不同？

例如，我有一个名为Poop的类，它有一个名为start（）的函数。我希望start（）为每个Poop实例做完全不同的事情。

因此，如果我调用a.start（），它可能会运行for循环10次迭代如果我调用b.start（）它可能会做一些其他事情就像问用户两个数字并返还总和。

我的代码：

obj.cpp

#include <string>
#include <obj.h>

//Concstructor
Poop::Poop (std::string get_name) {
    my_name = get_name;
}

//Obj functions implement here
void Poop::set_name(std::string name) {
    my_name = name; 
}

// I want to change this so that each object can behave differently
// when they call .start()
void Poop::start() {
    std::cout << "I am poop_1's start call" << std::endl;
}


//Event objects
Poop poop_1("bob");

obj.h

#include <iostream>
#include <string>

// defin obj
class Poop {
    //class attrs; private
    private:
        std::string my_name;
    public: //class function
        Poop(std::string); //constructor
        std::string get_name() {return (my_name);}
        void set_name(std::string); //sets Obj name
        void start(); // for the custom event; need to change this somehow

};

// global event objects
extern Poop poop_1;

Answer 1

执行此类操作的一种常见方法是使用the Strategy pattern。 Poop的每个实例都包含对策略对象的引用 - 一个扩展纯虚拟strategy类的类的实例，然后它将委托{{1}战略对象。

另一种方法是拥有一个实现脚本语言的库，并用脚本语言实现各种行为;每个对象可以包含不同的脚本，start()可以执行它。

Answer 2

对象存储状态，您可以使用适当的参数初始化对象，然后根据存储的参数调用操作以存档您想要的内容。

enum Action
{ 
   Action1 = 1,
   Action2
};

class Poop {
    private:
        std::string my_name;
        Action action;
    public: //class function
        Poop(const std::string& name, Action action); //constructor
        void start();
};

void Poop::start() {
   switch(action)  // start performs differently based on parameters
   {
    case Action1:
      std::cout << "I am poop_1's start call" << std::endl;
    break;
    case Action2:
      std::cout << "I am poop_1's start call" << std::endl;
    break;
    default:
    break;
   }
}

Answer 3

好吧也许它适用于仿函数。您可以在每个类中添加一个仿函数指针作为成员，仿函数将是基类和一些派生类将从它继承，每个派生类将具有不同的函数，它们将决定保存它们的类的功能。我从未尝试过，也没有看到过这样的事情，但我认为没有理由不应该这样做。

在c ++中，如何使同一个类的两个对象具有唯一的函数行为？

3 个答案: