es geht darum

ich will in meiner klasse den operator[] definieren,
dieser unterscheidet sich aber nur am rueckgabewert!

char operator[](int nPos) const;
wchar_t operator[](int nPos) const;

wie kann ich das problem loesen?
bin voellig ratlos

...
dieser unterscheidet sich ...

unterscheidet sich von was?

das is natuerlich bloed,
ich wollte es so machen das der benutzer entweder einen char oder einen wchar_t bekommt, je nachdem wohin das zeichen gehen soll

muss ich wohl oder uebel sowas wie "at(int, bool)" machen
gefaellt mir nur nicht wirklich
dreckszeuch #mecker

Wenn du willst, das er A oder B bekommt, kannst du ja auch Templates benutzen. Sowas:

T operator[](int nPos) const;

Dann muß der User sowas machen:

char b = a<char>[1]; // hoffe die Syntax ist richtig...
wchar_t b = a<wchar_t>[1];

Den Typ muß er sowieso kennen... ob mit oder ohne Template.

ich will in meiner klasse den operator[] definieren,
dieser unterscheidet sich aber nur am rueckgabewert!

char operator[](int nPos) const;
wchar_t operator[](int nPos) const;

wie kann ich das problem loesen?
bin voellig ratlos

durch zwei verschiedene klassen, eine für 'char' und eine für 'wchar_t', eventuell beide klassen von einer virtuellen basisklasse ableiten, die die ableitungen zwingt, den op[] zu überladen (ich weiss aber nicht ob das mit C++ möglich ist).

...oder ein template daraus machen.

Man kann sich dafür mal den Code von boost.any anschauen, die machen sowas über Templates. (worauf ich in meinem vorherigen Post abziehle)

Das es Klassen werden, macht die Sache nicht besser oder funktionsfähiger! Es ist wie gesagt, völlig egal! Weil C++ generell keine Unterscheidung bei den Return-Typen macht. Und Klassen werden in C++ eh als Build-in Types behandelt... also kannste vergessen. Nur Templates wären möglich.

hab's grad' mal ausprobiert, geht einfach nur mit ableiten

class A
{
    public: char operator[](int i)
    {
        return 10;
    }
};

class B : public A
{
    public: wchar_t operator[](int i)
    {
        return 1000;
    }
};

int main()
{
    A a;
    B b;
    printf ("%d\n", a[0]); // 10
    printf ("%d\n", b[0]); // 1000
}

pale dog schrieb:

class A
{
    public: char operator[](int i)
    {
        return 10;
    }
};

class B : public A
{
    public: wchar_t operator[](int i)
    {
        return 1000;
    }
};

int main()
{
  B bobject;
  wchar_t w = bobject[0];  //geht ja 
  char c = bobject[0];  //moep - hier wird der compiler ne Umwandlung von wchar_t nach char versuchen

  char c2 = bobject.A::operator[](0); // Aufruf des Operators aus der Basisklasse.
                         //sowas in der Art liefert das gewuenschte, ist aber recht haesslich
};

daher halte ich artchis template-loesung fuer die eleganteste...

daher halte ich artchis template-loesung fuer die eleganteste...

ich auch, keine frage

Was genau brauchst Du denn?

A) Eine Version für UNICODE-Programme und eine für MBCS/SBCS-Programme?

#include <tchar.h>
TCHAR operator[](int n) const;

Beide Versionen in einem Programm?

class MyFoo {
//
 public:
    operator char() const;
    operator wchar_t() const;
};

class String {
//...
    MyFoo& operator[](int n);
};

Das zurückgegebene MyFoo läasst sich dann wie gewünscht casten.

Grüsse

*this