如何获取模板 class 的值？

Question

I'm trying to get the value of a template class. To get the value of a class, I can easily do like:

int get_value()
{
    return *this;
}

But I want to create a class, and extend it, and don't make get_value() in all classes again. So, I did that:

template<typename T>
class _extend : public T
{
    public:
        auto _get_value()
        {
            return *this;
        }
};
template<typename T>
class extend : public _extend<T>
{
    public:
        T get_value()
        {
            auto value = this->_get_value(); /* It was `_get_value()`, changed to `this->_get_value()` due to the comments */
            T output = value;
            return output;
        }
};

But it's not working: output is nothing.

Edit

Sample program:

#include <iostream>

namespace kc
{
    template<typename T>
    class _extend : public T
    {
        public:
            auto _get_value()
            {
                return *this;
            }
    };
    template<typename T>
    class extend : public _extend<T>
    {
        public:
            T get_value()
            {
                auto value = this->_get_value();
                T output = value;
                return output;
            }
    };
    class A : public std::string, public extend<std::string>
    {
        public:
            using std::string::string;
    };
}

int main()
{
    kc::A a("a");
    std::cout << a.get_value() << std::endl;
}

Answer 1

The problem with the code in the question is the multiple inheritance. The *this that _extend<string>::get_value() will be called with is not the string that has a value.

Although I agree with @NicolBolas in comments in that I don't understand why you want this, but you can make a class template that will return the value of what it derives from with only one level of inheritance. You just need to give it a perfect forwarding constructor and have get_value() cast to the base type, ie

#include <iostream>
#include <string>

namespace kc
{
    template<typename T>
    class extend : public T
    {
    public:

        template<typename... Args>
        extend(Args&&... args) : T(std::forward<Args>(args)...) 
        {}

        T get_value()
        {
            return *static_cast<T*>(this);
        }
    };

}

int main()
{
    kc::extend<std::string> a("foo");
    std::cout << a.get_value() << std::endl;
}

Answer 2

Basically:

template<class C>
class extend : public C
{
    public:
        using C::C;
        auto get()
        {
            return *this;
        }
};

And a full example:

#include <iostream>

template<class C>
class extend : public C
{
    public:
        using C::C;
        auto get()
        {
            return *this;
        }
};

class e_string : public extend<std::string>
{
    public:
        using extend<std::string>::extend;
};

int main()
{
    e_string s = "Test";
    std::cout << s.get() << std::endl;
}