operator[] überladung

ich habe den operator[] für eine klasse überladen. nun kommt folgender fehler, den ich nicht versteht.
hat jemand eine erklärung? bitte, es wäre dringend.

start.cpp: In function void start()': start.cpp:26: choosingtype& array<type>::operator[](long unsigned int) [with
type = long unsigned int]' over operator[]' start.cpp:26: because worst conversion for the former is better than worst conversion for the latter start.cpp:26: choosingtype& array<type>::operator[](long unsigned int) [with
type = long unsigned int]' over `operator[]'
start.cpp:26: because worst conversion for the former is better than worst
conversion for the latter

björn

diese schei* smilies. braucht man so was wirklich?

tart.cpp: In function void start()': start.cpp:26: choosingtype& array<type>::operator[](long unsigned int) [with
type = long unsigned int]' over operator[]' start.cpp:26: because worst conversion for the former is better than worst conversion for the latter start.cpp:26: choosingtype& array<type>::operator[](long unsigned int) [with
type = long unsigned int]' over `operator[]'
start.cpp:26: because worst conversion for the former is better than worst
conversion for the latter

compiler ist g++

Shade Of Mine

zeig uns mal die signatur des operator[] und wie du ih aufrufst (+ deklaration der variablen)

template<class type> class array /* : public interface::array */ {
    protected:
      type* _pointer;
      unsigned long _size;

    public:
      inline array(void) {
        _pointer = (type*)0;
        _size = 0;
      }
      inline array(register type* pointer, register const unsigned long size) {
        _pointer = pointer;
        _size = size;
      }

      inline virtual void init(register type* pointer, register const unsigned long size) {
        _pointer = pointer;
        _size = size;
      }

      inline virtual const type& operator[](register const unsigned long index) const { return _pointer[index]; }
      inline virtual type& operator[](register const unsigned long index) { return _pointer[index]; }

      inline virtual const type* address(void) const { return _pointer; }
      inline virtual type* address(void) { return _pointer; }

      inline virtual const unsigned long size(void) const { return _size; }

      inline virtual array& operator=(register const array<type>& a) {
        if(_size < a._size) { return *this; }
        for(unsigned long i = 0; i < _size; i++) { _pointer[i] = a._pointer[i]; }
        return *this; 
      }

      inline virtual operator type*(void) { return _pointer; }
      inline virtual operator const type*(void) const { return _pointer; }

  };

aufruf und deklaration:

array<unsigned long> blabla;
  blabla[0] = 100;

Garrett

Hi,

die Frage scheint wenig mit dem Compiler selbst zu tun zu haben -> verschoben nach "C++".

HumeSikkins

Ah. Schöner Fehler
Aufgrund des Umwandlungsoperators nach type* ist der Aufruf des Index-Operators ist Mehrdeutig.

Es gibt zwei Möglichkeiten:
1. 0 ist vom Typ int. Der Op[] erwartet aber einen unsigned long.
Die erste Möglichkeit ist also Umwandlung von int nach unsigned long + Aufruf des Op[] deiner Klasse.
Kosten: Eine Standard-Konvertierung.

2. Die zweite Möglichkeit ist Aufruf des Umwandlungsoperators + Aufruf des built-in-Op[] für Zeiger. Dieser erwartet ein ptrdiff_t (auf den meisten Platformen ein int).
Kosten: Eine Benutzer-definierte-Konvertierung.

Nun ist eine Standard-Konverierung zwar besser als eine Benutzer-definierte-Konvertierung. Das spielt hier aber keine Rolle, da beide Umwandlungs-Sequenzen komplett ausgewertet werden müssen und ein Aufruf genau dann mehrdeutig ist, wenn beide Sequenzen einen Teil besitzen, der besser als einer der anderen Sequenz ist.
Hier ist die Standard-Konvertierung besser als die Benutzer-definierte-Konvertierung. Danach ist der Aufruf des built-in-Operator mit int aber ein perfekter Treffer.

Lösung:
Entweder du macht den Parameter deines op[] zu einem ptrdiff_t oder du machst die Umwandlung explizit.

PS:
const value-Parameter sind schwachsinn und sollten nicht verwendet werden.

sehr eigenartig...