So hier mal das Bsp:

#include <iostream>
#include<algorithm>
using namespace std;
template <typename CH> class basic_substring{
public:
    typedef typename basic_string<CH>::size_type size_type;

    basic_substring(basic_string<CH> &sarg, size_type iarg, size_type narg):s(sarg),i(iarg),n(narg){   }

    basic_substring<CH> &operator=(const basic_string<CH> &substring){
        s.replace(i,n,substring);
        n=substring.length();
    }
    operator basic_string<CH>()const{
        return basic_string<CH>(s,i,n);
    }
    operator const CH*()const{
        const char *c = copy(s.c_str()+i,s.c_str()+n+i,new char[n]) -n;
        return c;

    }
private:
    basic_string<CH> &s;
    size_type i;
    size_type n;
};
typedef basic_substring<char> Substring;
int main(int argc, char *argv[])
{
    string s="Class information items are simple name--value pairs that are specified using Q_CLASSINFO() in the source code.";
    Substring su(s,0,50);
    string s2="lawl"+Substring(s,0,50);         ///Hier gibts ne Fehlermeldung                                    
    cout<<s2<<endl;
    return 0;
}

Hat jemand ne Idee warum die Addition mit dem Substring nicht Funktioniert/Compiliert?

gruesse theBuck

error: no match for 'operator+' in 'std::basic_string<char, std::char_traits<char>, std::allocator<char> >(((const char*)"lawl"), ((const std::allocator<char>&)((const std::allocator<char>*)(& std::allocator<char>())))) + basic_substring<char>(((std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)(& s)), 0ul, 50ul)'

Dann scheinst du das Programm nicht komplett abgetippt zu haben, bzw. es kommt auf den nächsten Seiten eine Ergänzung. (Auf die Gefahr hin geschlagen zu werden: ich hab das Buch nicht...)

Grüssli

typedef basic_substring<char> Substring;
template <typename CH>
        string operator +(const CH *c,basic_substring<CH> s){
    return c+s.operator basic_string<CH>();
}

Ich war allerdings überrascht dass es mögich ist sowas zu machen:

#include <iostream>
#include<string>
#include<algorithm>
using namespace std;
template <typename CH> class basic_substring{
public:
    typedef typename basic_string<CH>::size_type size_type;

    basic_substring(basic_string<CH> &sarg, size_type iarg, size_type narg):s(sarg),i(iarg),n(narg){   }

    basic_substring<CH> &operator=(const basic_string<CH> &substring){
        s.replace(i,n,substring);
        n=substring.length();
    }
    operator int()const{
        return 5;

    }
private:
    basic_string<CH> &s;
    size_type i;
    size_type n;
};
int main(int argc, char *argv[])
{
    string s="text";
    cout<<5+basic_substring<char>(s,0,3)<<endl; ///Augen hierdrauf.
    return 0;
}

Deswegen dachte ich dass es bei dem Bsp vom ersten Post auch so funktionieren kann.

Gruss theBuck

Hallo, ich schätze mal Herr Stroustrup hatte vergessen zu erwähnen, dass man noch einen operator in dieser Form überladen muss: [...]

Der operator wird in <string> mitgeliefert. Du hast vermutlich einfach nur den #include vergessen/übersehen.

PS: wenn du statt der [code]-Tags [cpp]-Tags verwendest gibts für deinen Code noch Syntax-Coloring frei Haus!