Loại lớp cơ sở có thể lấy được từ một loại mẫu tự động không?

Question

Tôi đang cố gắng sử dụng mẫu meta-lập trình để xác định lớp cơ sở. Có cách nào để có được các lớp cơ sở tự động mà không rõ ràng chuyên cho từng lớp dẫn xuất?

class foo { public: char * Name() { return "foo"; }; }; 
class bar : public foo { public: char * Name() { return "bar"; }; }; 

template< typename T > struct ClassInfo { typedef T Base; }; 
template<> struct ClassInfo<bar> { typedef foo Base; }; 

int main() 
{ 
    ClassInfo<foo>::Base A; 
    ClassInfo<bar>::Base B; 

    std::cout << A.Name(); //foo 
    std::cout << B.Name(); //foo 
} 

hiện tại, bất kỳ phương thức tự động nào cũng sẽ cần chọn cơ sở được khai báo đầu tiên và sẽ không thành công cho các cơ sở tư nhân.

Answer 1

Giải pháp của tôi không thực sự tự động, nhưng tốt nhất tôi có thể nghĩ đến.

xâm nhập C++ giải pháp 03:

class B {}; 

class A : public B 
{ 
public: 
    typedef B Base; 
}; 

Không xâm nhập giải pháp C++ 03:

class B {}; 

class A : public B {}; 

template<class T> 
struct TypeInfo; 

template<> 
struct TypeInfo<A> 
{ 
    typedef B Base; 
}; 

Answer 2

Tôi không biết về bất kỳ mẫu chọn lớp cơ sở nào và tôi không chắc chắn mẫu nào tồn tại hoặc thậm chí là ý tưởng hay. Có nhiều cách mà trong đó điều này phá vỡ khả năng mở rộng và đi ngược lại tinh thần thừa kế. Khi bar công khai thừa kế foo, barlàfoo cho tất cả các mục đích thực tế và mã máy khách không cần phải phân biệt lớp cơ sở và lớp dẫn xuất.

Một typedef nào trong lớp cơ sở thường gãi ngứa các bạn có thể cần phải có trầy xước và là rõ ràng hơn:

class foo { public: typedef foo name_making_type; ... }; 

int main() { 
    Foo::name_making_type a; 
    Bar::name_making_type b; 
} 

Answer 3

Có thể với C++ 11 và decltype. Để làm điều đó, chúng ta sẽ khai thác rằng một con trỏ tới thành viên không phải là một con trỏ vào lớp dẫn xuất khi thành viên được thừa hưởng từ một lớp cơ sở.

Ví dụ:

struct base{ 
    void f(){} 
}; 
struct derived : base{}; 

Loại &derived::f sẽ void (base::*)(), không void (derived::*)(). Điều này đã đúng trong C++ 03, nhưng không thể có được loại lớp cơ sở mà không thực sự xác định nó. Với decltype, thật dễ dàng và chỉ cần chức năng này chút:

// unimplemented to make sure it's only used 
// in unevaluated contexts (sizeof, decltype, alignof) 
template<class T, class U> 
T base_of(U T::*); 

Cách sử dụng:

#include <iostream> 

// unimplemented to make sure it's only used 
// in unevaluated contexts (sizeof, decltype, alignof) 
template<class T, class R> 
T base_of(R T::*); 

struct base{ 
    void f(){} 
    void name(){ std::cout << "base::name()\n"; } 
}; 
struct derived : base{ 
    void name(){ std::cout << "derived::name()\n"; } 
}; 

struct not_deducible : base{ 
    void f(){} 
    void name(){ std::cout << "not_deducible::name()\n"; } 
}; 

int main(){ 
    decltype(base_of(&derived::f)) a; 
    decltype(base_of(&base::f)) b; 
    decltype(base_of(&not_deducible::f)) c; 
    a.name(); 
    b.name(); 
    c.name(); 
} 

Output:

base::name() 
base::name() 
not_deducible::name() 

Như ví dụ cuối cùng cho thấy, bạn cần phải sử dụng một thành viên đó thực sự là thành viên được thừa kế của lớp cơ sở mà bạn quan tâm.

Tuy nhiên, nhiều thành viên khác cũng phải xác định rõ ràng một thành viên cấp cơ sở:

struct base2{ void f(){} }; 

struct not_deducible2 : base, base2{}; 

int main(){ 
    decltype(base_of(&not_deducible2::f)) x; // error: 'f' is ambiguous 
} 

Đó là điều tốt nhất bạn có thể nhận được, không cần hỗ trợ trình biên dịch.

Answer 4

Điều gì với lớp cơ sở? Bạn có phải là lập trình viên .NET hoặc Java không?

C++ hỗ trợ đa kế thừa và cũng không có lớp cơ sở chung chung. Vì vậy, một loại C++ có thể có 0, một hoặc nhiều lớp cơ sở. Do đó, việc sử dụng các bài báo xác định được chống chỉ định.

Vì lớp cơ sở không có ý nghĩa gì, không có cách nào để tìm.

Answer 5

Tôi đang tìm kiếm một giải pháp di động cho vấn đề tương tự trong nhiều tháng. Nhưng tôi chưa tìm thấy nó.

G ++ có __bases và __direct_bases. Bạn có thể bọc chúng trong danh sách loại và sau đó truy cập bất kỳ phần tử nào của nó, ví dụ: a std::tuple với std::tuple_element. Xem libstdc++'s <tr2/type_traits> để sử dụng.

Tuy nhiên, đây không phải là di động. Clang++ currently has no such intrinsics.

Answer 6

Với C++ 11, bạn có thể tạo ra một phương pháp xâm nhập luôn luôn có một thành viên base_t, khi lớp học của bạn chỉ được thừa hưởng từ cha hoặc mẹ:

template<class base_type> 
struct labeled_base : public base_type 
{ 
    using base_t = base_type; // The original parent type 
    using base::base; // Inherit constructors 

protected: 
    using base = labeled_base; // The real parent type 
}; 

struct A { virtual void f() {} }; 

struct my_class : labeled_base<A> 
{ 
    my_class() : parent_t(required_params) {} 

    void f() override 
    { 
     // do_something_prefix(); 
     base_t::f(); 
     // do_something_postfix(); 
    } 
}; 

Với lớp đó, bạn sẽ luôn có một parent_t bí danh, để gọi các nhà xây dựng cha mẹ như thể đó là các nhà xây dựng base có tên ngắn hơn (có thể) và bí danh base_t, để làm cho lớp của bạn không biết tên loại lớp cơ sở nếu nó dài hoặc nặng nề.

Bí danh parent_t được bảo vệ để không hiển thị quảng cáo đó trước công chúng. Nếu bạn không muốn bí danh base_t là công khai, bạn luôn có thể kế thừa labeled_base làm protected hoặc private, không cần thay đổi định nghĩa lớp labeled_base.

Cơ sở đó phải có 0 thời gian chạy hoặc không gian trên không vì các phương thức của nó là nội dòng, không làm gì cả và không có thuộc tính riêng.