Aufgabe zum Üben

Braunstein

carr ist kein const char sondern ein const char* und du übergibst an der Stelle keinen String sondern nur einen Zeiger darauf.

ok danke jetzt habe ich mir was anderes überlegt.
Ich gebe jetzt die einzelnen buchstaben der Strings in dem Vector
zurück und diese kommen in das array.
Aber das Programm funktioniert mal wieder nicht richtig zur Laufzeit.

#include <iostream>
#include <string>
#include <vector>

using std::vector;
using std::cout;
using std::endl;
using std::cin;
using std::string;

int main()
{
   vector<string> svec;
   string buffer;
   while (getline(cin,buffer) )
      svec.push_back(buffer);
   char *carr = new char[svec.size()];
   for (vector<string>::iterator iter = svec.begin(); iter != svec.end(); ++iter, ++carr) { // auf string zugreifen
      for (int i = 0; i != (*iter).size(); ++i, ++carr)   // auf buchstabe zugreifen
      *carr = (*iter)[i];   // alle buchstaben in carr array übergeben
      cout << *carr;             // und diese ausgeben
   }
   delete[]carr; 
   system("PAUSE");
   return 0;
}

Braunstein

Versuchs mal so. (ungetestet weil zu müde)

int main()
{
   vector<string> svec;
   string buffer;
   size_t maxlen(0);
   while (getline(cin,buffer) )
   {
      svec.push_back(buffer);
      maxlen = max(maxlen,buffer.size());
   }
   size_t count(svec.size());
   char **carr = new char*[count];
   for( size_t i=0; i<count; ++i)
      carr[i] = new char[maxlen];
   for (vector<string>::iterator iter = svec.begin(); iter != svec.end(); ++iter, ++carr) { // auf string zugreifen
      strcpy(carr,iter->c_str()); 
      cout << *carr;             // und diese ausgeben
   }
   for( size_t i=0; i<count; ++i)
      delete[] carr[i];
   delete[]carr;
   system("PAUSE");
   return 0;
}

ok vielen dank so gehts.
Weiß noch einer warum das obere Programm nicht Funktioniert hat?
Also das mit die Buchstaben einzeln übergeben

Braunstein

Weil wahrscheinlich dein carr zu klein ist. Du lengst es mit der Größe der Anzahl der eingelesenen Strings an willst aber die Zeichen aus den einzelnen Strings reinkopieren. Natürlich kann einer der Strings mehr Zeichen enthalten als in carr reinpassen. Außerdem dereferenzierst du carr beim Ausgabe. Da kommt dann nur das erste zeichen raus.
carr ist eben ein Array für einen String der angegeben Größe. Du brauchst hier aber ein Array von Strings.
Wenn du die Strings nicht speichern willst geht auch das hier.

#include <iostream>
#include <string>
#include <vector>

using std::vector;
using std::cout;
using std::endl;
using std::cin;
using std::string;

int main()
{
   vector<string> svec;
   string buffer;
   size_t maxlen(0);
   while (getline(cin,buffer) )
   {
      svec.push_back(buffer);
      maxlen = max(maxlen,buffer.size());
   }   
   char *carr = new char[maxlen+1];
   for (vector<string>::iterator iter = svec.begin(); iter != svec.end(); ++iter, ++carr) { // auf string zugreifen
      for (int i = 0; i < iter->size(); ++i, ++carr)   // auf buchstabe zugreifen
      *carr = (*iter)[i];   // alle buchstaben in carr array übergeben
      carr[iter->size()] = '\0'; //Endnullbyte anfügen
      cout << carr;             // und diese ausgeben
   }
   delete[] carr;
   system("PAUSE");
   return 0;
}

*D*Evil

Schallalaa guckt mal auf die 1. seite @braunstein ... vllt fällt dir was auf ...

Danke Devil das funktioniert zwar,
aber das hier:

char** arr_data(new char*[vec_data.size()](NULL));

hab ich noch nicht gelernt in meinem Buch.

*D*Evil

Hmm in dem Fall nicht wirklich nötig (also das "(NULL)"), bewirkt aber (sollte es zumindest), dass alle c-strings (char*) mit NULL initialisiert werden.

int main()
{
    std::vector<std::string> vec_data;
    // daten in vec_data einlesen ...
    char** arr_data(new char*[vec_data.size()](NULL)); // array auf c-strings anlegen (c-string = char-array mit Nullterminierungszeichen) mit der Größe deines Vectors.
    for (std::size_t i(0); i < vec_data.size(); ++i)
    {
        arr_data[i] = new char[vec_data[i].length() + 1]; // c-string mit Größe des entsprechenden Elements des Vectors anlegen
                                                          // + 1 für Nullterminierung!
        std::strcpy(arr_data[i], vec_data[i].c_str()); // c-string kopieren (da c-string groß genug, automatische Nullterminierung!
    }
    // fertig ...
    for (std::size_t i(0); i < vec_data.size(); ++i) // vec_data.size() darf sich nicht verändert haben!
        delete [] arr_data[i]; // c-string löschen
    delete [] arr_data;
}

...

camper

(D)Evil schrieb:

Hmm in dem Fall nicht wirklich nötig (also das "(NULL)"), bewirkt aber (sollte es zumindest), dass alle c-strings (char*) mit NULL initialisiert werden.

ist unzulässig. Möglich ist bei Arrays nur Defaultinitialisierung.

char** arr_data = new char*[vec_data.size()]();

Irgendein Grund, ständig alles zu klammern? Das ist so furchtbar unübersichtlich.

char** arr_data(new char*[vec_data.size()](NULL));
das mit NULL verstehe ich schon aber das char**
also Zeiger auf Zeiger oder wie kann ich das verstehen?

CStoll

Flashgott schrieb:

char** arr_data(new char*[vec_data.size()](NULL));
das mit NULL verstehe ich schon aber das char**
also Zeiger auf Zeiger oder wie kann ich das verstehen?

Richtig verstanden - arr_data ist ein Zeiger auf einen (char)Zeiger (und wird verwendet als Array von C-style Strings).

warum verwendet man nicht einfach einen Zeiger?

char* arr_data = new char[vec_data.size()]();

*D*Evil

? Doofe Frage, nachdem das hier schon von 5 Leuten oder so erläutert wurde ...

char = /* Zeichen */
char* + '\0' = /* c-string (bzw. String) */
char** = /* Array von c-string's (bzw. String's) */

In deinem Fall hast du dann für einen ganzen String nur ein Zeichen zur verfügung, was dann bestenfalls für ein Nullterminierungzeichen reicht