bin gerade bei einer Übungsausfgabe angekommen, bei der ich nicht weiter weiss.
Also einer Liste von char* sollen einem Vector, bestehend aus Strings im "C-Stil", zugewiesen werden.
Mein Ansatz war:

list<char *> clst(3, '\0');
	vector<string> svec;
	svec.push_back("Aaaa"); svec.push_back("Bbbb");svec.push_back("Cccc");

	list<char*>::iterator lstit(clst.begin());
	for(vector<string>::iterator vecit(svec.begin()); vecit != svec.end(); ++vecit)
	{	
		if(lstit != clst.end())
		{
			*lstit = vecit->c_str();
			++lstit;
		}
	}

So gibt es allerdings ein Umwandlungsproblem von char* -> char const .
(Line 10).
Jetzt soll die Liste aber aus char und nicht char const* bestehen, welche anderen Möglichkeiten zur Umwandlung wären hier angebracht.
Und ist mit Zeichenstrings im C-Stil, aus dem der Vektor bestehen soll, sowas gemeint:

list<char*>bla ist nur eine liste mit pointer zur char-arrays aber keine char-array selber

willst du einen string aus einem vector in die liste haben musst du einen char-array erstellen, dafür must du speicher mit new reservieren und den pointer vom char-array den du erstellt hast kannst du dann die liste hauen. aber dann muss du am ende der anwendung die liste sicherheitshalber durchgehen und alle pointer mit delete "löschen".

std::list<char*> lst;
// fill lst
std::vector<char*> vec;
vec.resize(lst.size());
std::copy(lst.begin(), lst.end(), vec.begin());

Von vec nach Liste ginge es in etwa so:

std::list<char*> lst;
std::vector<std::string> vec;
//vector fuellen

for (std::vector<std::string>::iterator it = vec.begin(); it != vec.end; ++it)
{
  std::size_t clength = it->length() + 1; //der c-string hat noch das abschliessende '\0'
  char* str = new char[clength]; //neues char-array
  const char* pc = it->c_str();
  std::copy(pc, pc+(clength), str); //oder auch std::strcopy
  lst.push_back(str);
}

//have fun with the list!

while (! lst.empty())
{
  delete[] lst.front();
  lst.pop_front();
}

Naja mit dem back_inserter hast du dann halt wieder die wiederkehrenden Vergrößerungen. Es sei denn, du benutzt v.resize( l.size())

Ich hoff du meinst reserve() denn mti resize() UND back_inserter hast du dann N default-konstruierte Elemente und danach nochmal N kopierte

std::string::c_str() liefert dir einen const char* auf das erste Zeiche vom String. Allerdings kannst du den nicht einfach in die Liste stecken, da dir erstens das const in die Quere kommt (const ist es weil du über den Pointer nicht in den String-Eingeweiden Rumwerkeln sollst) und zweitens dem string ausdrücklich erlaubt ist, seinen Inhalt zu einem späteren Zeitpunkt an einen anderen Ort zu kopieren und den Speicher wieder freizugeben. In so einem Fall würden die pointer in der List dann irgendwo in den Speicher zeigen, wo schon längst kein String mehr anzutreffen ist.

Ich hoff du meinst reserve() denn mti resize() UND back_inserter hast du dann N default-konstruierte Elemente und danach nochmal N kopierte

Man achte bitte auf die Uhrzeit *reusper*

vielleicht gehts auch ohne allokieren, da die zeiger solange gültig sind solange man die strings nicht anfasst.
wenn du also den vector nicht benutzt kannst du die zeiger in der liste speiciehrn

Die Restritkionen wären aber immens. Viele Zugriffe auf den vector können dafür sorgen, dass der neuen Speicher allozieren muss, dadurch die Strings umkopiert, wodurch wiederum die Zeiger in der Liste ungültig werden (können). Wenn man den vector umkopiert kommts natürlich genauso. Da vermutlich irgendjemand anderes den Code später modifiziert muss dem mit großen roten Warntafeln und Starkstromzäunen klargemacht werden, dass er auf keinen Fall den vector berühren soll... Dann doch lieber dynamisch Speicher anfordern oder noch besser garnicht erst mit blanken char-pointern hantieren. Gut dass das nur als Übung gedacht war