[c++] Problem bei Rückgabe eines Parameters aus Funktion

[guddy]

Hallo,

vielleicht könnt ihr mir bei folgendem Problem helfen.

Ich habe folgende Funktion:

void konfigvareinlesen(){

std::string dummy, val[7]; 
std::ifstream in("Variableninput.dat");     	// neuen Lese-Stream erzeugen
//1. Zeile
std::getline(in, dummy, ':'); 			// Einlesen bis :
in.ignore(); 					// Leerzeichen ignorieren
std::getline(in, val[0]); 			// Einlesen bis Zeilenende
const char *prozess= val[0].c_str();
}

Wie kann ich den wert von prozess an eine Variable der mainfunktion übergeben ohne ihn als rückgabewert zu übergeben. Ich hab da was von callbyreference gelesen und auch schon rumprobiert. Leider mit mäßgiem erfolg.

Grüße

Guddy

 

[vfl_freak]

Moin Guddy,

indem Du entweder Deinen Zeiger auf "prozess" VOR der Funktion "konfigvareinlesen" definierst (vermutlich dann ja im Hauptprogramm, oder?) und dann als Parameter an diese übergibst, oder an der Stelle eine eigene Variable anlegst, ebenfalls übergibst und am Ende "prozess" dort reinschreibst!

Anders bekommst Du Deinen lokal innerhalb der Funktion definierten Wert nicht raus - oder eben als Rückgabewert der Funktion ..... ;-)

Gruß
Klaus

 

[guddy]

Wenn ich das richtig verstanden habe so:

int main() {
const char prozess;
konfigvareinlesen(&prozess);
}

void konfigvareinlesen( const char *prozess){
std::string dummy, val[7]; // dummy liest String bis : ein, val[] ist stringarray 

std::ifstream in("Variableninput.dat");     	// neuen Lese-Stream erzeugen
//1. Zeile
std::getline(in, dummy, ':'); 			// Einlesen bis :
in.ignore(); 					// Leerzeichen ignorieren
std::getline(in, val[0]); 			// Einlesen bis Zeilenende
*prozess= val[0].c_str();
}
:

bringt mir den Fehler:

error: uninitialized const `prozess'

wenn ich das gleiche mit einem beliebig anderen int wert(nicht const) mache funktionierts. Was mach ich falsch?


Grüße

Guddy

 

[vfl_freak]

Hallo Guddy,

schau Dir mal Deine Deklaration von "prozess" genau an - dann sollte sich eigentlich die zweite Fehlermeldung von selbst erklären (BTW: "char const *" ist identisch zu "const char*") !!

Zudem solltest Du hier dann irgendwo (ob im Hauptprogramm oder in der Funktion ist weitgehend egal, wenn Du den Zeiger resp. die Referenz korrekt übergibst) auch Speicher reserviert werden :

const char *prozess = new char[...irgendeine Größe...];

Abschließend dann das delete nicht vergessen !!

Gruß
Klaus

 

[guddy]

Ich blick das leider nicht....

 

[vfl_freak]

Hallo guddy,

nun, Du versucht ein char beim Funktionsaufruf einen char* zuzuweisen!!
Und in Main übergibt Du die Referenz auf die char-Variable .....

Da Du ja String einlesen willst, würde ich in etwa wie folgt vorgehen:

int main() 
{
      const char *new_process = null;
      konfigvareinlesen( new_process );
      delete[] new_process;
}

void konfigvareinlesen( const char *prozess)
{
      std::string dummy, val[7];         // dummy liest String bis : ein, val[] ist stringarray
      std::ifstream in("Variableninput.dat");   // neuen Lese-Stream erzeugen
      //1. Zeile
      std::getline(in, dummy, ':');            // Einlesen bis :
      in.ignore();                             // Leerzeichen ignorieren
      std::getline(in, val[0]);                // Einlesen bis Zeilenende
      int iLaenge = val[0].size();
      prozess = new char[iLaenge];
      prozess= val[0].c_str();
}

Ist allerdings ohne Gewähr, da ich es nicht ausprobiert habe!!
Da Du immer nur einen String verarbeitest (val[0]), wäre das StringArray eigentlich auch überflüssig .... Solltest Du auf Dauer wirklich 7 Strings verarbeiten wollen, dann auch die Variable "prozess" entsprechend erweitert werden (als StringArray, als StringVector, List oder wie auch immer). Ich persönlich würde hier dann einen StringVector bevorzugen !

Gruß
Klaus

 

[vfl_freak]

Hier für Dich ein vielleicht noch hilfreicher Auszug aus der C++-Hilfe zum Stichwort CONST

The const keyword specifies that a variable's value is constant and  tells the compiler to prevent the programmer from modifying it.
const int i = 5;

i = 10; // Error
i++;    // Error 
In C++, you can use the const keyword instead of the #define preprocessor directive  to define
constant values. Values defined with const are subject to type  checking, and can be used in place of constant 
expressions. In C++, you can  specify the size of an array with a const variable as follows:

const int maxarray = 255;
char store_char[maxarray];  // Legal in C++; illegal in C 

In C, constant values default to external linkage, so they can appear only in  source files. In C++, constant values default 
to internal linkage, which allows  them to appear in header files.
 The const keyword can also be used in pointer declarations.
char *const aptr = mybuf;  // Constant pointer

*aptr = 'a';       // Legal
aptr = yourbuf;    // Error A pointer to a variable declared as const can be assigned only to a  pointer that is also 
declared as const.
const char *bptr = mybuf;  // Pointer to constant data

*bptr = 'a';       // Error
bptr = yourbuf;    // Legal You can use pointers to constant data as function parameters to prevent the  function from 
modifying a parameter passed through a pointer.
 You can call constant member functions only for a constant object. This  ensures that the object is never modified.

birthday.getMonth();    // Okay
birthday.setMonth( 4 ); // Error 
You can call either constant or nonconstant member functions for a  nonconstant object. You can also overload a member 
function using the  const keyword; this allows a different version of the function to be  called for constant and
nonconstant objects. You cannot declare constructors or destructors with the const  keyword.

Gruß
Klaus

 

[guddy]

Hallo Klaus,

ich habe einen Stringarray angelegt da ich mehrere Variablen übergeben will. Mit den zu int gecasteten Werten funktioniert das auch. leider nicht mit den const char werten. Dein code wird zwar kompiliert, es wird aber nix ausgegeben. Warum muss ich eigentlich in der Funktion Platz reservieren, wenn ich danach eh den Wert mit

prozess= val[0].c_str();

zuweise?

Ich hab das jetzt wie du umgesetzt:

int main(){
const char *prozess = 0;
std::cout << prozess << "\n"; 
}

void konfigvareinlesen(const char *prozess){
std::string dummy, val[7]; // dummy liest String bis : ein, val[] ist stringarray 

std::ifstream in("Variableninput.dat");     	// neuen Lese-Stream erzeugen
//1. Zeile
std::getline(in, dummy, ':'); 			// Einlesen bis :
in.ignore(); 					// Leerzeichen ignorieren
std::getline(in, val[0]); 			// Einlesen bis Zeilenende
int iLaenge = val[0].size();
prozess = new char[iLaenge];
prozess= val[0].c_str();
}

in der Datei variableninput.dat steht:

Prozessname: blabla

 

[vfl_freak]

Hallo guddy,

habe gerade erst so richtig realsiert, dass Du ja ohnehin in ein string-Array einliest ;-)
Von daher sollte das Folgende (a) funktionieren (zumindest weitgehend ) und (b) von der Handhabung deutlich 'eleganter' sein (erspart Dir das Gefummel mit const char) :

int main()
{
    vector<string> theVec;

    theVec = konfigvareinlesen( );

    vector<string>::iterator itXXX;
    for( itXXX = theVec.begin(); itXXX != theVec.end(); itXXX++ )
    {
        std::cout << *itXXX.data() << "\n"; 
    } // for
} // main()

vector<string> konfigvareinlesen( void )
{
    int iAnzElemente = 7;
    vector<string> tempVec;
    std::string dummy, val[iAnzElemente];
    std::ifstream in("Variableninput.dat");

    // alle 7 Elemente einlesen
    for( int i = 0; i < iAnzElemente; i++ )
    {
        std::getline(in, dummy, ':');
        in.ignore();
        std::getline(in, val[i]);
        tempVec.push_back( val[i] );
    }
    return tempVec;
} // konfigvareinlesen()

Der Iterator ist dabei so was ähnliches, wie die Zählvariable in der for-Schleife!

Hoffe, dass Dir das weiterhilft - ich benutze sowas in dieser Art hier ständig!!

tschüss
Klaus

 

[guddy]

Hallo Klaus,

danke, die Lösung ist wirklich eleganter.
Ich dachte nur, da ich die eingelesenen Werte am Ende als char und int Werte benutzen will, dass es am besten für mich wäre diese auch schon mit diesem Typ zurückzugeben. Das macht meine main etwas übersichtlicher. ;-)

Danke für deine Hilfe.

Grüße

Guddy