C++의 기본 클래스에서 하위 데이터에 액세스

Question

머리/종이에서 반복적으로 반복 해본 결과,이 시나리오에 대해 "최선"또는 "가장 정확한"방법이 무엇인지 알 수 없습니다.

설정 :

• 나는 클래스 'A'나에게 제공 있습니다. 나는이 수업을 바꿀 수 없다. 이 클래스에는 여러 가지 공용 메소드가 있습니다.
• 많은 클래스 'A'를 사용하고 동일한 메소드 이름을 사용하여 코드에서 A와 B를 서로 바꿔 사용할 수 있도록 'A'클래스를 많이 작성한 클래스 'B'를 작성했습니다.
• 이제는 복잡한 작업을 수행하기 위해 클래스 'A'또는 클래스 'B'(또는 동일한 공용 메소드로 향후에 다른 클래스)를 취할 수있는 클래스 'C'를 작성하려고합니다.

'C'가 'D'를 상속하고 필요한 가변 유형을 제공 할 수있는 동안 '수퍼 클래스' 'D'를 작성하여 일반적인 작업을 수행하려고 시도했습니다. 그러나 'D'는 'C'개인 변수를 볼 수 없습니다.

나는이 구조체를 잘못 생각하여 여기에서 상속을 올바르게 사용하는 방법을 생각하고있다. 클래스 D에 C 클래스의 유형을 알았습니다. 강제로 캐스팅 할 수 없습니다. D는 또한 'o'를 사용해야하는 많은 기능을 갖고 있으며 각각의 잠재적 인 클래스 유형에 대해 각각을 다시 구현하지 않아도되도록 노력하고 있습니다.

나는 또한이 일반적인 문제입니다 확신 해요,하지만 난 지금 이일에 대한 대답을 찾고 있었어요 ...

이

단순화 된 예제 코드 :

// Class A has been provided to me, and cannot be modified. 
#include <classA.h> 

class B { 
    public: 
    B(A *x, int num): z(x), n(num) {}; 

    int num(void) {return n;}; 
    // Other methods to operate on objects of class A as if they were a single 
    // one, using same method names. Maybe somehow inheritance is better here? 

    private: 
    A *z; 
    int n; 
}; 


class D { 
    public: 
    D(void): s(5) {}; 

    // 'o' to be provided by child class, must have method 'num' 
    void doThat(void) {return s+o.num();}; 

    private: 
    int s; 
}; 

// So we can handle multiple types of devices that have the same public methods 
// This is just a class to get the private object that superclass D will need 
class C: public D { 
    public: 
    C(B *h): o(h) {}; 

    private: 
    B *o; 
}; 

A ar[2] = { A(1), A(2) }; 
B l(ar, 2); 
C j(&l); 

이 나를를 가져옵니다 'o'는 범위에 포함되지 않습니다.

Arduino: 1.8.1 (Windows 10), Board: "Arduino/Genuino Uno" 
sketch_feb11b.ino: In member function 'void D::doThat()': 
sketch_feb11b:26: error: 'o' was not declared in this scope 
    void doThat(void) {return s+o.num();}; 
exit status 1 
'o' was not declared in this scope 

나는 새롭게 다시 C로 ++ 많은 많은 년 후, 그래서 나는 또한 내가 지금 처음에 제대로 문제를 접근하고 있지 않다 받아 들일만큼 기꺼이.

Answer 1

당신은 당신은 너무 많은 세부 사항을 왼쪽 D

template<typename T> 
class D: 
{ 
    D(const T* t): m_t(t) {}; 
    int doThat(void) { return m_t->num(); }; 

private: 
    T* m_t; 
} 

A ar[2] = { A(1), A(2) }; 
B l(ar, 2); 
C<B> j(&l); 

Answer 2

class D { 
public: 
    D(): s(5) {} 
    // Your child class must overload getter method getNum() 
    int doThat() { 
    return s + getNum(); 
    } 
private: 
    int s; 
    // pure virtual, must be overload 
    virtual int getNum() = 0; 
... 
}; 

class C : public D { 
private: 
    B* o; 
    // overload pure func 
    int getNum() override { 
    return o->num(); 
    } 
public: 
    // Use default D ctor 
    C(B* b) : D(), o(b) {} 
... 
}; 

A ar[2] = { A(1), A(2) }; 
B l(ar, 2); 
C j(&l); 
j.doThat(); // return 5 + ar->num