Implement a named class

[nicow]

Hi everybody,

I am trying to implement some kind of named class. It would look something like this:

class MyClass
{
    virtual std::string getName() = 0;
};

and now (what doesn't pass the compilation)

template <std::string NAME> class MyNamedClass
{
    std::string getName() { return NAME;}

};

and so every time I would like to have a class with a name, I could just do the following:

FinalClass : public MyNamedClass<"FinalClass">{};

The idea is not to have to always reimplement getName(), and just do it concisely in the declaration. Any idea on how to do something like that?

Thanks,
Nicolas

[kbw]

It isn't something you can do with templates pre se, you'll have to generate the function with a macro.

[SIK]

The idea is not to have to always reimplement getName(), and just do it concisely in the declaration

seems like a simple class will suffice, like this:

class NameClass
{
   NameClass(const std:string & name) : m_name(name) {}

   std:string getName() const
   {
      return m_name;
   }

private:
   std:string   m_name;
};

// Then we can do:

FinalClass : public NameClass("FinalClass") {};

[LB]

@SIK: Line 16 is not valid syntax.

[SIK]

@LB: Thanks - it should be:

class FinalClass : public NameClass("FinalClass") {};

[LB]

@SIK: that's still not valid syntax - you can't use the constructor there. Also you used single colons instead of double colons for std::string.

http://ideone.com/hylK76

Please take the time to at least test your code, or warn that it is untested.

[helios]

Why do you need to get the name of the class?

[JLBorges]

Simple:

#include <iostream>
#include <string>
#include <typeinfo>

struct named
{
    virtual ~named() = default ;
    virtual std::string name() const { return typeid(*this).name() ; }
};

namespace Detail { struct IntermediateClass : named {}; }

class FinalClass : public named {} ;

int main()
{
    Detail::IntermediateClass ic ;
    FinalClass fc ;
    std::cout << ic.name() << "    " << fc.name() << '\n' ;
}

http://coliru.stacked-crooked.com/a/b5c2d73922aaf2f2

Demangled:

#include <iostream>
#include <string>
#include <typeinfo>

    #ifdef __GNUG__
        #include <cxxabi.h>
        #include <memory>
        #include <cstdlib>

        std::string demangle( const char* name )
        {
            int status ;
            std::unique_ptr< char, decltype(&std::free) >
                cstr( abi::__cxa_demangle( name, nullptr, 0, &status ), &std::free ) ;
            return std::string( status == 0 ? cstr.get() : name ) ;
        }

    #elif defined _MSC_VER

        #include <cstring>

        std::string demangle( const char* name )
        {
            const auto p = std::strchr( name, ' ' ) ;
            return p ? p+1 : name ;
        }

    #else
        std::string demangle( const char* name ) { return name ; }
    #endif // __GNUG__

struct named
{
    virtual ~named() = default ;
    virtual std::string name() const { return demangle( typeid(*this).name() ) ; }
};

namespace Detail { struct IntermediateClass : named {}; }

class FinalClass : public named {} ;

int main()
{
    Detail::IntermediateClass ic ;
    FinalClass fc ;
    std::cout << ic.name() << "    " << fc.name() << '\n' ;
}

http://coliru.stacked-crooked.com/a/ce351b2160e231e5
http://rextester.com/KKFR91615