Hier ist mein Ansatz:
( Ich bekomme immer nur das a ausgeben und danach nur noch irgendwelche ascii Zeichen. )

#include <iostream.h>
#include <windows.h>

using namespace std;

char* name();

int main()
{

char *c=NULL;

c = name () ;

        cout<< c[0]<<endl;
        cout<< c[1]<<endl;
        cout<< c[2]<<endl;

system("PAUSE");
}
//---------------------------------------------------------------------------

char* name()
{

char data[10];

        data[0]='a';
        data[1]='b';
        data[2]='c';

return data;
}

machs zB so:

#include <iostream> // keine .h !!
#include <windows.h>
#include <string>

std::string name()
{
    std::string name = "abc";
    return name;
} 

void  name1(char * preallokiertesArrayGenuegenderGroesse)
{
    preallokiertesArrayGenuegenderGroesse = name().c_str();
} 

int main()
{
    std::cout << name();

    char * prealloc =  new char[512];
    name1(prealloc);

    for(int i=0;i<3;++i) std::cout << i << ":" << prealloc[i] << "  ";

    delete [] prealloc;

    system("PAUSE");
}

Arrays verhalten sich anders als alles andere in C++ und du machst hier auch prompt alles falsch, was man falsch machen könnte.

#include <iostream>  // Das heißt iostream!
#include <windows.h>      // Wozu?
#include <cstdlib>        // Für system
#include <vector>         // Für vector

using namespace std;

vector<char> name();   // Ich ändere nur den Typen...

int main()
{

vector<char> c = name () ;  // ...überall wo er vorkommt.

        cout<< c[0]<<endl;
        cout<< c[1]<<endl;
        cout<< c[2]<<endl;

system("PAUSE");  
}
//---------------------------------------------------------------------------

vector<char> name()
{

vector<char> data(10); // Keine eckigen Klammern hier, sonst hätte man ein Array von vectoren

        data[0]='a';
        data[1]='b';
        data[2]='c';

return data;  // Und schon klappt alles
}

Aber wieso soll man nicht #include <iostream.h> benutzen ?

( #include <windows.h> war noch von vorhin drin hab da was getestet ... )

void  name1(char * preallokiertesArrayGenuegenderGroesse)
{
    preallokiertesArrayGenuegenderGroesse = name().c_str();
}

Und das soll jetzt was machen?

Lars

Aber wieso soll man nicht #include <iostream.h> benutzen ?

Weils das schon lange nicht mehr gibt, allerhöchstens noch aus Gründen der Abwärtskompatibilität. Wo auch immer du dies her hast: Deine Quelle ist seit über 12 Jahren veraltet, mindestens von der Standardkonformität her und höchstwahrscheinlich auch vom Stil. Diese Quelle sollte in Zukunft von die nicht mehr benutzt werden.

@padreigh: Du hattest doch vorhin noch so ein wunderhübsches Beispiel wie das mit string ein ganz sauberer Zweizeiler ist. Warum hast du das weggemacht? Weil's so schön war, schreibe ich es nochmal hin:

#include <iostream>
#include <string>

using namespace std;

string name()
{
 return "abc";
}

int main()
{
  cout << name() << endl;
}

Und das soll jetzt was machen?

Hubs hast recht :)) das tut so nich

std::string name()
{
    std::string name = "abc";
    return name;
} 

// für den Fall das du wirklich char* aus irgend einem Grund brauchst, kannst du einfach
// einen genügend großen char * "reservieren" und den start davon der Methode mitgeben.
// die kann dann direkt in den Speicherbereich reinschreiben .... IMHO: nimm string, iss einfacher ;)
void  name1(char * preallokiertesArrayGenuegenderGroesse)
{
    preallokiertesArrayGenuegenderGroesse [0] = 'a';
    preallokiertesArrayGenuegenderGroesse [1] = 'b';
    preallokiertesArrayGenuegenderGroesse [2] = 'c';
}

SeppJ schrieb:

@padreigh: Du hattest doch vorhin noch so ein wunderhübsches Beispiel wie das mit string ein ganz sauberer Zweizeiler ist. Warum hast du das weggemacht? Weil's so schön war, schreibe ich es nochmal hin:

Ist noch da, 2 Zeilen höher das ist nur so kurz, das geht unter.