von unary_function erben

pumuckl

die typedefs aus der Basisklasse werden nciht vererbt, was du aber anzunehmen scheinst.

struct base
{
		typedef bool test_type;
};

class derived: public base
{
	public:

		inline test_type test2()
		{
			return true;
		}
};

Mhmmm ... und warum kompiliert das anstandslos?

Mhmm war natürlich Unsinn ... Danke für den Hinweis.

template <typename T>
struct base
{
		typedef T test_type;
};

class derived: public base<bool>
{
	public:

		inline test_type test2()
		{
			return true;
		}
};

Wobei das auch kompiliert oO Was ist da los?

SeppJ

Entschuldige, wusste nicht, dass argument_type und result_type öffentliche typedefs sind. Die werden schon vererbt, aber bei Templates muss man dann noch explizit sagen, dass es eine Typenbezeichnung ist:

template <typename T>
struct base
{
        typedef T test_type;
};

template<typename N> class derived: public base<N>
{
    public:

  inline typename base<N>::test_type test2()
        {
            return true;
        }
};

Wenn du das typename weglässt, bekommst du genau dein Problem, weil dann nicht klar ist, was test_type ist, denn dazu müsste man N im voraus kennen:

template <typename T>
struct base
{
        typedef T test_type;
};

template<typename N> class derived: public base<N>
{
    public:

  inline test_type test2()
        {
            return true;
        }
};

unskilled

fleisig schrieb:

template <typename T>
struct base
{
		typedef T test_type;
};

class derived: public base<bool>
{
	public:

		inline test_type test2()
		{
			return true;
		}
};

Wobei das auch kompiliert oO Was ist da los?

sicherlich, weil du den msvc nimmst?!
der "kann" das nämlich.

bb

pumuckl schrieb:

die typedefs aus der Basisklasse werden nciht vererbt, was du aber anzunehmen scheinst.

Aber ist nicht der einzige Sinn von unary/binary_function genau diese typedefs zur Verfügung zu stellen?

template< typename path_type >
	class path_rule: public std::unary_function< const path_type&, bool >
	{
		public:
			inline typename std::unary_function< const path_type&, bool >::result_type
					operator()(typename std::unary_function< const path_type&, bool >::argument_type) const
			{

			}
	};

So kompiliert es natürlich ... wirklich was gekommt hab ich damit aber auch nicht oO

unskilled schrieb:

sicherlich, weil du den msvc nimmst?!
der "kann" das nämlich.

g++ 4.4.3

template<typename _Arg, typename _Result>
    struct unary_function
    {
      typedef _Arg argument_type;   ///< @c argument_type is the type of the
                                    ///     argument (no surprises here)

      typedef _Result result_type;  ///< @c result_type is the return type
    };

Mein Problem ist absolut analog zu dem test - Beispiel. Ich versteh einfach nicht, warum test kompiliert und das Original nicht??

SeppJ

Der Unterschied ist, dass bei dir die erbende Klasse selbst ein Template ist und der typedef von diesem Templateparameter abhängt. Das hast du bei deiner Testklasse so nicht gemacht. Siehe meinen vorherigen dafür wie dein Testfall aussehen muss um den Fehler zu zeigen und wie man den Fehler behebt.