Определение общих функций-членов

Question

Есть ли способ достичь чего-то подобного в C ++:

template<typename SomeClass>
auto SomeClass::someMemberFunction() { ... }

Идея состоит в том, что если данная функция-член объявлена ​​в классе, но не определена, она получит определение по умолчанию изэтот шаблон.

Answer 1

Насколько мне известно, тип шаблона не может работать в этом случае.Вы написали определение функции шаблона, но вам нужно объявление.Декларация, которую вы можете записать как одна часть тела, а НЕ из некоторых членов класса, таких как:

class A {
    //some members
};

class A {   //redefinition, not possible "partial class" like in C#
    //the other members
};

Решением будет наследование, но здесь вам не нужны шаблоны:

#include <iostream>

using namespace std;

class Base{
    protected:
    Base(){}    
    public: 
    int someMemberFunction() { 
    return 5; 
    }   
};

class A: public Base{
    public:
    int X(){
        return x;   
    }

    void setX(int _x){
        x=_x;
    } 
    private:  
    int x;          
};

int main(){
    A a;
    a.setX(3);
    //Base b;   Base() is protected
    cout <<"a.x="<<a.X()<<endl;
    cout <<"a.someMemberFunction(): "<<a.someMemberFunction()<<endl;
    return 0;
}

Answer 2

Вы можете просто добавить общий базовый класс следующим образом:

class DefaultsAsBase
{   
    public:
    void Bla() { std::cout << "Bla" << std::endl; }
    void Blub() { std::cout << "Blub" << std::endl; }
};  

template < typename T>
class TemplatedOnes: public DefaultsAsBase
{   
    public:
    void Bla() { std::cout << "templated Bla" << std::endl; }
};  

// and the specialized if needed
template <>  
class TemplatedOnes<int>: public DefaultsAsBase
{   
    public:
    void Blub() { std::cout << "Specialized Blub" << std::endl; }
};  

int main()
{
    TemplatedOnes<float> tf; 
    TemplatedOnes<int> ti; 

    tf.Bla();
    tf.Blub();

    ti.Bla();
    ti.Blub();
}   

Если хотите, вы можете добавить базовый класс в качестве параметра в шаблон, что делает его частично CRTP. Реальные CRTP также приводят к производному классу, который не является частью вашего вопроса, но, если хотите, вы можете добавить его.

class DefaultsAsBase
{
    public:
    void Bla() { std::cout << "Bla" << std::endl; }
    void Blub() { std::cout << "Blub" << std::endl; }
};

class OtherDefaultAsBase
{
    void Bla() { std::cout << "Bla other" << std::endl; }
    void Blub() { std::cout << "Blub other" << std::endl; }
};

template < typename T, class CRTP_BASE>
class TemplatedOnes: public CRTP_BASE
{
    public:
    void Bla() { std::cout << "templated Bla" << std::endl; }
};

// and the specialized if needed
template <typename CRTP_BASE>
class TemplatedOnes<int, CRTP_BASE>: public DefaultsAsBase
{
    public:
    void Blub() { std::cout << "Specialized Blub" << std::endl; }
};

int main()
{
    TemplatedOnes<float, DefaultsAsBase> tf;
    TemplatedOnes<int, DefaultsAsBase> ti;
    TemplatedOnes<int, OtherDefaultAsBase> ti2;

    tf.Bla();
    tf.Blub();

    ti.Bla();
    ti.Blub();

    ti2.Bla();
    ti2.Blub();

}