Ich habe ein Problem mit indexable (aus boost rauskopiert, weil ich es abgeben muss und keine Lust habe, 20 boost-Header mitzuliefern):

#include <iostream>

template <typename T, typename const_reference, typename size_type>
struct indexable
{
	const_reference operator[](size_type n) const
	{
		return *(static_cast<const T&>(*this) + n);
	}
};

struct IPv4 : indexable <IPv4, const unsigned char&, size_t>
{
public:
	typedef unsigned char value_type;
private:
	typedef unsigned int saving_type;
	static const char Seperator = '.';
	value_type vals[4];
public:
	explicit IPv4(value_type a = value_type(), value_type b = value_type(), value_type c = value_type(), value_type d = value_type())
	{
		vals[0] = a;
		vals[1] = b;
		vals[2] = c;
		vals[3] = d;
	}

	value_type& operator[] (size_t i)
	{
		return vals[i];
	}

	friend std::ostream& operator << (std::ostream& s, const IPv4 &these)
	{
		for (size_t i(0), e(4-1); i != e; ++i)
		{
			s << static_cast <IPv4::saving_type> (these[i])
			  << IPv4::Seperator;
		}
		s << static_cast <IPv4::saving_type> (these[3]);
		return s;
	}
};

int main()
{
	IPv4 eins (127, 0, 0, 1);
	std::cout << eins;
}

Der Compiler (MSVC) sagt mir jetzt aber:

MSVC schrieb:

1>...\test\main.cpp(38) : error C2678: binary '[' : no operator found which takes a left-hand operand of type 'const IPv4' (or there is no acceptable conversion)
1> ...\test\main.cpp(29): could be 'IPv4::value_type &IPv4::operator [](size_t)'
1> while trying to match the argument list '(const IPv4, size_t)'
1>...\test\main.cpp(41) : error C2678: binary '[' : no operator found which takes a left-hand operand of type 'const IPv4' (or there is no acceptable conversion)
1> ...\test\main.cpp(29): could be 'IPv4::value_type &IPv4::operator [](size_t)'
1> while trying to match the argument list '(const IPv4, int)'

Ja - das Problem sollte eigtl offensichtlich sein und beim Code sollte es auch nichts zu kommentieren geben...

Hat jemand ne Idee?

bb

sicher das das so klappt? du erhöhst ja die refernez um n und indizierst das wieder
versuchs mal so

return *(reinterpret_cast<const T *>(this) + n);

Da lies selber nach:
http://www.boost.org/doc/libs/1_39_0/libs/utility/operators.htm#dereference

Oder vielleicht wäre dieser Artikel noch interessant:
http://www.c-plusplus.net/forum/viewtopic-var-t-is-240706.html

Jedenfalls verwendest du boost::indexable definitiv falsch.

Grüssli

sicher das das so klappt? du erhöhst ja die refernez um n und indizierst das wieder

Die Umsetzung ist korrekt, die Verwendung nicht.

@unskilled:
um indexable<T, R, D> zu verwenden, muss operator+ (T, D) und T::operator*() definiert sein, und zwar so dass die Addition konvertierbar in T ist und die Dereferenzierung etwas konvertierbares in R liefert. Schau dir am Besten die Beispiele in der Doku nochmal an.

@dravere: den artikel hab ich scho gelesen - allerdings ist indexable da nicht gezeigt worden - und den einen satz, wo es tatsächlich steht, hab ich iwie net gelesen -.-

allerdings hab ich in der boost-doku kein bsp gefunden - vll bin ich ja auch einfach nur blind, aber eigtl hab ich doch nen ganzes weilchen gesucht ^^

bb

edit: eigtl such ich was, was mir die arbeit abnimmt, op[] immer einmal für const und einmal für non-const zu überladen... aber irgendwie funtzt das nich - geht das überhaupt, oder geht das bei op[] gerade mal nicht so schön, wie bei dem rest?
ich dachte, ich überlade den non-const und der für const macht eben nen const cast und ruf dann meinen op[] non-const auf, also so was hier in der richtung:

template <typename T, typename const_reference, typename size_type>
struct indexable
{
	const_reference operator[](size_type n) const
	{
		return (static_cast<const T*>(this)->operator[](n));
	}
};

aber als es so am anfang net geklappt hatte, hab ich dann einfach das aus boost 1:1 übernommen, ohne noch ma nachzudenken -.-

PS: aber danke für den Irrtum, die Iterator-Operatoren werden im nächsten Artikel zu boost::operators besprochen, da kann ich gleich nochmal drauf hinweisen dass das nicht für Container da ist

PS: aber danke für den Irrtum, die Iterator-Operatoren werden im nächsten Artikel zu boost::operators besprochen, da kann ich gleich nochmal drauf hinweisen dass das nicht für Container da ist

Nur deshalb hab ich das doch gepostet

#define MACRO_CREATE_OPERATOR_INDEXABLE(C, R, S) \
	R operator [](S index) \
	{ \
		return const_cast<R>((*static_cast<C const*>(this))[index]); \
	}

class Foo
{
	unsigned char data[4];

public:
	MACRO_CREATE_OPERATOR_INDEXABLE(Foo, unsigned char&, std::size_t)

	unsigned char const& operator [](std::size_t index) const
	{
		return data[index];
	}
};

Ja, Makros sind nicht so schön, aber es ist am einfachsten, so dass auch die Überladung funktioniert. Man bemerke übrigens, dass ich aus der nicht konstanten Version auf die konstante Version zugreife, ist etwas sicherer

Grüssli

und was bitte macht den Unterschied zwischen den Makro und einem einfach als Member definierten Operator? - Mal abgesehn davon dass das Makro eine Zeile mehr bei der Definition und eine zusätzliche Zeile für den Aufruf braucht (und am besten noch eine Zeile für den #undef)

naja - es geht halt für jeden container - aber so richtig gefallen tuts mir auch nich -.-
danke trotzdem, mal gucken, ob ichs nehm oder doch den gleichen code zweimal schreibe ^^

bb

und was bitte macht den Unterschied zwischen den Makro und einem einfach als Member definierten Operator? - Mal abgesehn davon dass das Makro eine Zeile mehr bei der Definition und eine zusätzliche Zeile für den Aufruf braucht (und am besten noch eine Zeile für den #undef)

Du kannst es wiederverwenden? Das Makro ist natürlich nicht für eine einzige Klasse gedacht, was allerdings das indexable wohl auch nicht gedacht ist

Wenn man die Sache als Klasse implementiert, hat man leider das Problem, dass die Überladung nicht hinhaut, weil es ein anderer Scope ist. Da müsste man gleich auch noch ein using hinschreiben, was die Sache gleich komplex macht. Deshalb das Makro statt einer Klasse, von welcher man ableiten kann.

Grüssli