char* cArray[3]={"A","B","C"};

vector<char*>vArray(3)??????????

danke im voraus
buntehaare

vector<char const*> v = { "yay", "hell yeah", "piissosexy" };

Error: initzialisation with {...] is not allowed for object of type std::vector, std::allocator

Visual Studio 2010

Man sollte noch sagen, dass dies ein neues Feature im C++11er Standard ist und eventuell erst bei deinem Compiler aktiviert werden muss (auf älteren GCCs z.B. mit -std=c++0x). Dieses Feature ist jedoch nicht sehr exotisch, es sollte auch in älteren Compilern schon längst existieren.

na toll da predigen immer alle cArray's sind dem c++ vector so unterlegen wegen den Buffer über und unterläufen und und und ..., und dann kann man nicht einmal mit runden klammer initialisiseren soll man das dann so machen?

vector<char*>z(16);
 char* u[16]={"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"};
 int xx=0;
 while(xx  < 16){
	 z[xx]=u[xx];
	 xx++;
 }

vector<char*>z(16);
 char* u[16]={"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"};
 int xx=0;
 while(xx  < 16){
	 z[xx]=u[xx];
	 xx++;
 }

Das geht aber auch wesentlich kürzer, selbst mit C++98:

char* u[16]={"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"};
vector<char*>z(u,u+16);

vector<char*>z(u,u+16);

Übrigens würde ich das wie folgt erweitern:

template<typename T, std::size_t N>
std::size_t array_size(T(&)[N]) { return N; }

...

char const *u[] = { "foo", "bar", "baz" };
std::vector<char const *> z(u, u + array_size(u));

um doppelte Datenhaltung (der Arraylänge) zu vermeiden.

Außerdem sei auf Boost.Assign hingewiesen, womit man auch

std::vector<char const *> v;

v += "foo", "bar", "baz", "qux";

schreiben kann. Generell ist derartiger syntaktischer Zucker natürlich von untergeordneter Bedeutung; in den meisten Fällen stehen die Daten, die man in einen Vektor packen will, erfahrungsgemäß nicht zur Compilezeit fest.

Übrigens würde ich das wie folgt erweitern:

template<typename T, std::size_t N>
std::size_t array_size(T(&)[N]) { return N; }

...

char const *u[] = { "foo", "bar", "baz" };
std::vector<char const *> z(u, u + array_size(u));

Oder auch

char const *u[] = { "foo", "bar", "baz" };
std::vector<char const *> z(begin(u), end(u));

ach nein, das ist ja auch C++11...

Liegt nicht an vector, sondern daran, dass Microdoof zu blöd ist, den aktuellen Standard zu implementieren. Nimm den GCC, der ist im Moment allen anderen Compilern überlegen.

Gibt es eigentlich keine Funktion, um Pi auszublenden?

[...] in den meisten Fällen stehen die Daten, die man in einen Vektor packen will, erfahrungsgemäß nicht zur Compilezeit fest.

Genau! Und wenn man nur an einer unveränderlichen Lookuptabelle oder andere Konstanten interessiert ist, dann darf man auch ruhigen Gewissens "C-Arrays" verwenden statt std::vector und std::string.

314159265358979 schrieb:

Liegt nicht an vector, sondern daran, dass Microdoof zu blöd ist, den aktuellen Standard zu implementieren. Nimm den GCC, der ist im Moment allen anderen Compilern überlegen.

Gibt es eigentlich keine Funktion, um Pi auszublenden?

Ja jemand hat mal ein Script im Forum veröffentlicht um Beiträge von bestimmten Usern zu verstecken.

PIs Beiträge sind zu 100% Bullshit.

http://www.c-plusplus.net/forum/212868-130

Liegt nicht an vector, sondern daran, dass Microdoof zu blöd ist, den aktuellen Standard zu implementieren. Nimm den GCC, der ist im Moment allen anderen Compilern überlegen.

Den gcc würd ich auch gern verwenden, aber ich habe noch keine IDE gefunden die an visual studio 2010 + visual assist x rankommt.
Langsam wirds etwas offtopic

Langsam wirds etwas offtopic

Dann fütter ihn doch nicht auch noch.

Back to topic: Wenn die diversen C++11-Mechanismen noch nicht zur Verfügung stehen, sollte man sich wirklich wie von seldon erwähnt boost.Assign ansehen. So oder so sollte man sich im skizzierten Fall aber auch überlegen, ob ein std::array (oder boost::array) nicht die bessere Wahl wäre.

Liegt nicht an vector, sondern daran, dass Microdoof zu blöd ist, den aktuellen Standard zu implementieren. Nimm den GCC, der ist im Moment allen anderen Compilern überlegen.

Auch wenn ich mit der Ansicht, dass microschrott doof ist, zu 99% übereinstimme kann man nicht sagen, dass ihre Entwicklertools doof sind. Sicher der gcc ist dem Microsoft Compiler in Sachen c++11 Unterstützung überlegen, jedoch hat Microsoft schon einige Features implementiert.

314159265358979 schrieb:

Liegt nicht an vector, sondern daran, dass Microdoof zu blöd ist, den aktuellen Standard zu implementieren. Nimm den GCC, der ist im Moment allen anderen Compilern überlegen.

Auch wenn ich mit der Ansicht, dass microschrott doof ist, zu 99% übereinstimme kann man nicht sagen, dass ihre Entwicklertools doof sind. Sicher der gcc ist dem Microsoft Compiler in Sachen c++11 Unterstützung überlegen, jedoch hat Microsoft schon einige Features implementiert.

Ja, und zwar jene, die keinen Aufwand machen:
- RValue-Referenzen: Das Verschieben von Objekten konnte der Optimierer im Hintergrund angeblich schon vorher, und jetzt kann der Benutzer das eben steuern

• auto : Der Typ des rechten Ausdrucks muss sowieso bestimmt werden, auto dürfte ein ~10-Zeiler sein, genauso wie nullptr und >> vs. > >
• static_assert : Simpel
• long long : Toll, __int64 gibts ja auch noch gar nicht ewig..
  Mehr Nennenswertes habe ich hier nicht gefunden.

Unterm Strich: Microsoft ist vielleicht nicht zu blöd, aber zu faul, C++11 zu implementieren. Sieht man ja an VS11, das kaum mehr bringt.

Unterm Strich: Microsoft ist vielleicht nicht zu blöd, aber zu faul, C++11 zu implementieren. Sieht man ja an VS11, das kaum mehr bringt.

Ich würde eher sagen: Du bist vielleicht nicht zu blöd, aber zu faul, um dich richtig zu informieren. Lambdas wären noch erwähnenswert gewesen. Aber viel wichtiger: http://channel9.msdn.com/Shows/C9-GoingNative/GoingNative-Live-at-BUILD-Herb-Sutter-Joanna-Mason-Tony-Goodhew

Unterm Strich: Microsoft ist vielleicht nicht zu blöd, aber zu faul, C++11 zu implementieren. Sieht man ja an VS11, das kaum mehr bringt.

Das liegt einfach daran, dass C++11 bei MS wirtschaftlich und politisch zeimlich weit unter angesiedelt ist. Die wollen ihr C# verkaufen.

Es ist schon so, dass gcc bei der Umsetzung von C++11 die Nase vorn hat - die haben früher damit angefangen, und einige Neuerungen (nennenswert: variadische Templates) kommen sogar von da. Man hat das damit erkauft, dass die Funktionsweise des C++0x-Modus für einen Compiler extrem stark fluktuierte: Es gibt viele Möglichkeiten, Code zu schreiben, den gcc 4.3 anstandslos frisst, den gcc 4.7 aber ablehnen muss. Wenn man früh damit angefangen hat, gccs C++0x-Modus zu benutzen, hat man sich viel Frustration eingehandelt, aber dann hat man ja wohl auch gewusst, worauf man sich einließ.

Microsofts Ansatz an dieser Stelle war ganz anders, und musste auch anders sein. Wenn man Kunden hat, denen man Compiler für richtig Kohle verkauft, hat man immer Schwierigkeiten, zu erklären, dass neuere Versionen Code ablehnen, den ältere gefressen haben - man hatte etwas derartiges ja schon mal mit MSVC 6 erlebt. Insofern ist die Entscheidung, relativ spät damit anzufangen, durchaus nachvollziehbar. Es sollte mich nicht wundern, wenn es sogar Stimmen gegeben hätte, die auf die Finalisierung des Standards warten wollten - aber darüber kann ich nun wirklich nur spekulieren.

Dass C++ bei Microsoft ein Waisendasein führt, kann ich jedenfalls nicht nachvollziehen - Lambdas sind schon ein ziemlich großer Wurf, und in VC11 kommt eine Menge Concurrency-Kram dazu, der auch nicht ganz simpel ist (und von gcc bislang nicht unterstützt wird, was ein Grund dafür sein mag, dass VC11 ihn haben wird). Zudem erfand man neue Adaptersprachen zu .net und COM, die mit einigem Aufwand gewartet werden müssen; solche Investitionen macht man nicht, wenn man C++ für überholt hält. Vielleicht hat man mal gehofft, alles auf .net umstellen zu können, aber wenn man sich diese Illusion wirklich gemacht hat, spricht einiges dafür, dass sie zwischenzeitlich verworfen wurde.

All das hindert mich nicht daran, die Abwesenheit insbesondere variadischer Templates in VC11 zu lamentieren und wohl noch ein oder zwei Compilerversionen zu überspringen (abhängig davon, wie schnell das jetzt alles geht), aber die Nase zu rümpfen und zu sagen: "Tja, Microsoft, was haste denn erwartet?" scheint mir keine angemessene Reaktion zu sein.