Question

使用大量派生类，我希望用driver.find_element_by_link_text("Switch to Advanced Game Log").click() driver.find_element_by_xpath(".//*[@id='advanced_div']/div[2]/div/span[6]").click()运算符显示其成员。随着更多类的使用，覆盖新成员的运算符/其他函数可能变得非常麻烦。我很好奇是否有办法完成类似下面的事情？ 当然会溢出。

np.nanpercentile

如果不可能有类似的（递归），那么替代解决方案是什么？ IE在运算符体内传递不同的参数或调用<< /其他函数返回。感谢。

Answer 1

这可能会帮助你，但Base类在这种情况下是完全抽象的！这是Base＆amp; 2派生类

TIME

使用它而不是堆栈的另一种方法是在堆上但确保清理所有内存。

#include <conio.h>
#include <string>
#include <iostream>

class Base {
    friend std::ostream& operator<<( std::ostream& out, const Base* const pObj );

private:
    std::string m_strName;

public: 
    std::string getName() const { return m_strName; }
    virtual ~Base(){} // Default Okay 

protected:
    explicit Base( std::string strName ) : m_strName( strName ) {}

    virtual void printData( std::ostream& out ) const = 0;

}; 

std::ostream& operator<<( std::ostream& out, const Base* const pObj ) {
    out << pObj->m_strName << std::endl;
    pObj->printData( out ); 
    return out;
}

class DerivedA : public Base {
private:
    int m_value;

public:
    explicit DerivedA( int& a ) : Base( std::string( "DerivedA" ) ), m_value( a ) {}

protected:
    virtual void printData( std::ostream& out ) const override;
};

void DerivedA::printData( std::ostream& out ) const {
    out << "Value: " << m_value;
}

class DerivedB : public Base {
private:
    float m_value;

public:
    explicit DerivedB( float& f ) : Base( std::string( "DerivedB" ) ), m_value( f ) {}

protected:
    virtual void printData( std::ostream& out ) const override;
};

void DerivedB::printData( std::ostream& out ) const {
    out << "Value: " << m_value;
}

int main () {

    int a = 4;
    float b = 3.2f;

    DerivedA derivedA( a );
    DerivedB derivedB( b );

    // Notice I Used The Address Of Operator Here Due To How The << operator Is Defined
    std::cout << &derivedA << std::endl << std::endl;
    std::cout << &derivedB << std::endl << std::endl;

    std::cout << "Press any key to quit"  << std::endl;
    _getch();
    return 0;
}

我最终在这里做的是我创建了一个朋友＆lt;＆lt;基类中的运算符，它将调用printData（）函数，该函数被定义为纯虚方法。请记住，您无法直接构造Base对象，因为它完全是Abstract。这里每个Derived类型都必须实现自己的printData（）函数！这样每个类都将知道如何使用＆lt;＆lt;运算符，因为它是在继承自的基类中定义的。这是继承的力量。所以现在我只需要定义重载运算符一次并且可以将它用于每个派生类型，但是所有派生类型都必须指定printData（）函数，因为每个派生类型可能具有您想要打印的不同内部数据。

如果您不想使用我在基类中定义的指针表示法＆lt;＆lt;运营商声明＆amp;定义你也可以这样做：

int main () {

    int a = 4;
    float b = 3.2f;

    DerivedA derivedA = new DerivedA( a );
    DerivedB derivedB = new DerviedB( b );

    // Since This Is On The Heap I Can Use The Class Directly
    std::cout << derivedA << std::endl << std::endl;
    std::cout << derivedB << std::endl << std::endl;

    // Make Sure To Clean Up Memory
    delete derivedA;
    delete derivedB;

    std::cout << "Press any key to quit"  << std::endl;
    _getch();
    return 0;
}

如果需要，可以在基类中包含这两个版本，以便流操作符＆lt;＆lt;知道如何通过对象，引用或指针来打印你的类！

派生成员和重载的Ostream运算符

1 个答案: