标签: overloading

我正在运行一个期权定价模型，该模型为四种不同的期权生成四个值。

class EuroOption
{
private:
    double S;    //underlying stock price
    double X;    //strike price
    double sigma;    //volatility
    double T;    //time to expiration
    double r;    //risk-free rate
    double b;    //cost of carry
public:
    EuroOption();    //default constructor
    ~EuroOption();    //destructor
    EuroOption(const EuroOption& eo);    //copy constructor
    EuroOption& operator = (const EuroOption& source);    //assignment operator
    EuroOption(vector<double> Batch1);
    EuroOption(vector<double> Batch2);  //this is the error: redeclaration
    //EuroOption(vector<double> const Batch3);
    //EuroOption(vector<double> const Batch4);

以下是 .cpp 的源材料：

EuroOption::EuroOption(vector<double> Batch1) : S(60), X(65), sigma(0.30), r(0.08), T(0.25), b(r)
{
}

EuroOption::EuroOption(vector<double> …

java中方法重载和重写的区别？没有给出正确答案。下面是java代码。

家长班

public class Parent {
    void display() {
        // some code
    }
}

儿童班

public class child extends Parent
    void display(int a) {
        // some code
    }
}

问题：这个方法是重载、重写还是无？

假设我有以下课程：

class Point{
private:
int x,y;

public:
int get_x() const {return x;}
int get_y() const {return y;}

Point() :x(0),y(0){}
Point(int x,int y):x(x),y(y){}
Point(const Point& P){
    x = P.get_x();
    y = P.get_y();
}
Point& operator=   (const Point& P) {
            x = P.get_x();
            y = P.get_y();

    return *this;
}
friend ostream& operator<<(ostream& os,const Point& P) {

    os<<"["<<P.get_x()<<", "<<P.get_y()<<"]";
    return os;
}


Point operator - (const Point &P){
    return Point(x-P.get_x(),y-P.get_y());
}

friend bool operator > (const Point &A, const Point &B) {
    return …

是否可以重载参数为List<>不同类型的方法？

例如，我希望创建两个这样定义的方法：

public void getChanges(List<TypeOne>){}
public void getChanges(List<TypeTwo>){}

但是，由于两种方法都接受 a List，因此存在冲突。有什么方法可以使方法考虑列表中的对象类型吗？

对我来说，编译器没有意识到签名确实不同，因为 aList<TypeOne>与 不同，这似乎很奇怪List<TypeTwo>。

在包规范中，函数名称仅出现一次，因此它不会重载。在包体中，相同的函数名称使用不同的参数集出现两次。其中之一的参数与封装规格中的参数相同。我的问题是，包体中的“第一个 func”是否实际被调用，如果是，它到底在做什么？它正试图回归自己。

    --package specification
    CREATE OR REPLACE 
    PACKAGE jtestpkg
      IS
    FUNCTION testfunc(p_num IN NUMBER, p_out1 IN out varchar2, p_out2 IN out varchar2)
      RETURN NUMBER;
    END jtestpkg;

    --package body
    CREATE OR REPLACE 
    PACKAGE BODY jtestpkg
      IS
      --first func
      function testfunc
            (p_num IN NUMBER,
             p_out1 IN OUT varchar2) 
            return number is
                v_out2 varchar2(50);
      BEGIN
      dbms_output.put_line('invoking first func');
          RETURN testfunc(
              p_num,
              p_out1,
              v_out2);
      END;
      --second func
      FUNCTION testfunc(
                p_num IN NUMBER,
                p_out1 IN OUT varchar2,
                p_out2 IN OUT varchar2)
        RETURN NUMBER
        IS
        v_num …

对于以下方法：参数类型的顺序是否会导致唯一的方法签名？

static void PrintOrderCost(double totalCost, string customerName)
{

}

上述方法签名：PrintOrderCost(double, string)

static void PrintOrderCost(string customerName, double totalCost)
{

}

上述方法签名：PrintOrderCost(string, double)

在下面的示例中，函数模板 ( quartic) 使用重载的全局函数 ( square)。编译时，仅考虑在模板本身之前声明的重载，因此square(int)使用 so 而不是square(double)，即使square(double)在使用模板之前声明也是如此。

int square(int);

template<typename T>
T quartic(T value) {
    return square(square(value));
}

double square(double);

double x(double y) {
    return quartic(4.0); // Uses square(int), wanted square(double)
}

有没有一种方法可以根据square使用模板时可用的内容来决定哪个重载版本，以便用户可以实现他使用的square任何类型？T

注意：奇怪的是，MSVC 将使用square(double)，而 GCC、clang 和 icc 使用square(int)。

所以我正在开发一个小项目，我正在使用 websocket 客户端库，为了创建一个WebSocketApp处理 websocket 连接的对象，您可以使用类似的方法实例化该对象

ws = websocket.WebSocketApp(uri, on_open=on_open, on_message=on_message, on_ping=on_ping)

现在我有一个名为on_message回调函数（对象？）的函数，它处理传入的消息，或者更确切地说如何处理它们，并且ws当完整消息传入时（显然）由我创建的对象调用。 on_message被定义为实例化对象时的回调WebSocketApp。

on_message 是这样的

def on_message(ws, message):
    print(message)

我想要的是这样的：

def on_message(ws, message, someList)
    somelist.append(message)

我当然可以使用全局变量来引用我想要更新的对象（在本例中是一个列表），但这似乎不是正确的方法，如果我可以传递对该对象的引用，那就太好了我想在初始化WebSocketApp对象时进行更新，例如：

ws = websock.WebSocketApp(uri, on_message=on_message(ref_to_Obj), on_open=on_open, on_close=on_close)

但显然这不起作用，因为我收到TypeError: on_message() missing 2 required positional arguments: 'message' and objRef'错误。

我不完全确定如何解决这个问题。我想到了子类化，但也不确定如何实现它。查看源代码，WebSocketApp它说它有 2 个参数，1）WebSocketApp类本身和 2）从服务器接收的 utf-8 数据。我从来没有传递这些，并且我假设库在创建它们时只是将这些引用传递出去，但是我如何重载它以包含其他参数？首先想到的是使用 *args 或 **kwargs 进行重载，但又不确定如何实现它。我之前问过，建议使用 lambda 函数，但我也不知道如何让它工作。

我目前正在开发一个处理指向成员函数的指针的模板函数。它最初看起来像这样：

template <typename C, typename RT, typename... P>
auto CreateTestSuite(RT(C::* pFunc)(P...))
{...}

然而，我很快发现，如果我尝试向它传递一个指向 const 成员函数的指针，模板将无法识别它。所以我然后添加了这个重载版本：

template <typename C, typename RT, typename... P>
auto CreateTestSuite(RT(C::* pFunc)(P...) const)
{...}

对于分别具有 const 和 non-const 的两个不同的成员函数，它工作得很好。但是，如果我尝试调用CreateTestSuite指向重载成员函数的指针，则会出现问题。

例如，假设我有以下 A 类：

class A
{
public:
    return_type test(...) {...}
    return_type test(...) const {...}
};

现在当我尝试进行函数调用时

CreateTestSuite(&A::test);

编译器将无法判断我正在使用哪个重载版本。此外，这个问题不能通过显式指定模板参数来解决，因为它们对于CreateTestSuite.

如何从两个版本中明确选择？

编辑： 我可以接受对CreateTestSuite.

非常感谢。

我无法理解干净的方法来做到这一点。我想要一个名为set_delay()带有各种参数的函数。我可以设置 3 种不同的“延迟类型”：恒定、均匀和正常。这是我目前拥有的：

def set_delay_constant(delay):
    continue

def set_delay_uniform(min_delay, max_delay):
    continue

def set_delay_normal(mean, std_dev, timeout):
    continue

我遇到的问题是每个函数中大约 80% 的代码是重复的。我见过的想法是：

def set_delay(delay_type, delay=None, min_delay=None, max_delay=None, mean=None, std_dev=None, timeout=None):
    continue

但是当我需要用更多的延迟类型来扩展它时，我可以看到它变得非常长并且难以阅读。最“Pythonic”的方法是什么？谢谢你！