Da es bereits sehr viel in Bezug auf C++0x gibt, werde ich keine Details zu den Sprachfeatures erklären, sondern hauptsächlich mich darauf konzentrieren die Features zu zeigen, welche auch tatsächlich bereits möglich sind und den Sinn dahinter nur kurz an einem Beispiel demonstrieren. Der Technical Report 1 (TR1) wird weitestgehend ebenfalls unterstützt und darauf werde ich weniger eingehen, da das ansonsten viel zu viel wird. Nur kurz angemerkt seie, dass dort Sachen, wie tuples, arrays, regex, smart pointer, random usw. zu finden sind. Diese Features benutzen die folgenden Sachen ebenfalls teilweise recht intensiv und sind teils nur so elegant überhaupt umsetzbar geworden.

auto Keyword:
Das auto Keyword ist dazu da, um den Typen einer Variable (oder auch Funktion) automatisch wählen zu lassen aus dem Argument, mit dem es Initialisiert wird. Das ist vor allem dort sehr nützlich, wo man viele verschachtelte templates hat und die Typen von den template Argumenten abhängig sind. Das iterieren durch einen vector wird ein nun sehr einfach:

std::vector<int> v;
for (auto it = v.begin (); it != v.end (); ++it )
	std::cout << *it;

In der Tat gibt es noch eine schönere Variante, was in anderen Sprachen als foreach bekannt ist, allerdings wird das Feature (for für Ranges) leider noch nicht unterstützt, darum werde ich das Beispiel unterlassen, damit keine Verwirrung aufkommt. (Bei Interesse weiss google mehr!)

decltype:
Mit diesem neuen Keyword kann der Typ eines Ausdruckes bestimmt werden. Man kommt natürlich gleich auf die Idee, dass man damit ja Sachen, wie das hier machen kann:

int a = 2;
float b = 1.0f;
decltype ( a*b ) c = a*b;

Aber das ist dank dem ebenfalls dazu gekommenen Keyword auto völlig überflüssig, denn wir können auch das hier schreiben:

int a = 2;
float b = 1.0f;
auto c = a*b;

Was natürlich viel schöner aussieht.
decltype braucht man aber dennoch an gewissen Orten. Zum Beispiel bei Funktionen: (Die neue Art Funktionen mit dem Rückgabetypen hinten zu schreiben sollte in einem entsprechenden C++0x Paper nachgelesen werden).

template<class T, class U>
auto mul(T x, U y) -> decltype(x*y)
{
	return x*y;
}

Wichtig ist hier eigentlich nur, dass wir wissen, oder eben nicht, was der Rückgabetyp ist. Der Compiler allerdings kann das für jede Instanzierung feststellen. Darum können wir das auch dem Compiler überlasse mit dem Schlüsselwort decltype. (Das hinter dem Pfeil soll den Typen des Rückgabewertes darstellen).
Auf eine Art ist das dem Keyword like in Eiffel ähnlich. (Allerdings nicht gleich, denn dort sind keine Ausdrücke erlaubt, sondern nur einzelne Variablen).

Rvalue Referenzen:
Rvalue Referenzen sind auf den ersten Blick wahrscheinlich nicht sehr interessant. Sie ermöglichen es nicht-konstante Rvalues (also das, was nur rechts von einer Zuweisung stehen kann) zu binden. Effektiv wird so etwas möglich:

int&& n = 5;
std::cout << ++n;

Wozu das nötig ist? - Es ermöglicht eine sehr effiziente Implementierung für std::swap und ermöglicht perfect forwarding, für gewisse Bibliotheken unerlässlich ist (siehe dazu std::function).

Lambda Expressions:
Achja. Jetzt kommt das, auf das alle sehnlichst gewartet haben.
Lambda Ausdrücke können helfen Code besser lesbar zu machen und sind teilweise wirklich sehr elegant. Bis jetzt musste man für Funktionen, die Benutzerdefinierten Code übernehmen sollten immer eine Funktion oder einen Funktor schreiben, was teilweise recht mühsam ist da extra eine Klasse oder Funktion zu definieren. Diese Zeiten sind mit Lambda Expressions entgültig vorbei. Auch hier werde ich nicht genau auf die Details eingehen was Lambda Expressions sind, sondern gehe davon aus, dass der geneigte Leser, falls er die noch nicht kennen (und lieben) gelernt hat sich selbst über das Internet informieren kann. Doch ich will die Gelegenheit nicht auslassen ein kleines Code Beispiel zu posten:

auto l = [](){std::cout << "hallo aus lambda welt!";};
l ();

Hier sieht man auch sehr schön, wozu man auto so alles brauchen kann. Die Standardbeispiele von den Sortierargumenten im Funktionsaufruf, lasse ich einmal aus, weil ihr, wenn ihr euch dafür interessiert bestimmt noch drauf stossen werded. - Darum nochmal ein kleines anderes Beispiel:
Mit einem kleinen Trick lassen sich sogar rekursive Lambda Ausdrücke schreiben und was fällt uns da für eine Funktion ein? Klar:

std::function<int(int)> fac = [&] (int n)->int{ 
			if ( n == 0) return 1; 
			else return n*fac (n-1); 
			};
std::cout << fac ( 5 );

auto lässt sich hier nicht benutzen, darum muss der Typ der Funktion ausgeschrieben werden, was aber dank dem in TR1 enthaltenen Funktionwrapper sehr intuitiv geschen kann.Keine Kommentare | Kommentieren

static Assert:
Dieses Features wird vor allem die Template-Metaprogrammierung gebraucht. Es macht eigentlich das gleiche, wie das bekannte Makro assert. Allerdings bereits zur Kompilierzeit und kann einen String ausgeben, was nicht in Orndung ist. Das macht die Metaprogrammierung einiges freundlicher, weil man nicht mehr merkwürdige Compiler Ausgaben interpretieren lernen muss.
Wenn ich z.B möchte, dass Integer mindestens 64 Bit sind, dann kann ich das so festlegen:

static_assert ( sizeof ( int ) >= 8, "int ist nicht 64 Bit!" );

Was dann eine sehr schöne Ausgabe gibt:

c:..main.cpp(45): error C2338: int ist nicht 64 Bit!
Build FAILED.

Sehr lesbar und klar, was mir gesagt werden soll, oder nicht? Wenn man das jetzt vergleicht mit dem, was man so bekommt, wenn eine Templateinstanzierung falsch ist, dann ist das eine enorme Erleichterung für den Entwickler.

Template Aliases:
Ein viel indirekt nachgefragtes Feature sind sogenannte Template typedefs. Intuitiv erwartet man ja, dass so etwas hier geht:

template<typename T, typename U>
class foo
{};
 
// Achtung! Nicht gültig, weder in C++98, noch in C++0x!
template<typename U>
typedef foo<int,U> foo_int;

Allerdings war das mit einem typedef zu schwer zu lösen, also gibt es eine Alternative Syntax, aber mit dem genau gleichen Prinzip:

template<typename U>
using foo_int = foo<int,U>;

Das sollte funktionieren laut Microsoft. Allerings bekomme ich da einen Fehler..

C2988: unrecognizable template declaration/definition

- Unbekannt -

Ich habe keine Ahung warum.. Offiziell wird das seit 2007 unterstützt und ich habe nichts gefunden, dass das wiederrufen hat.
Ich vermute mal, dass da einfach noch ein Bug vorliegt und das das noch behoben wird.

Nullptr:
Ebenfalls etwas, was zuerst keinen grossen Anschein macht, aber trotzdem einen grossen Nutzen haben wird, ist entlich etwas um einen Null Zeiger anzuzeigen, anstatt den einfach mit 0 zu identifizieren. Nullptr ist vor allem nützlich um gewisse implizite Konvertierungen zu verhindern und ebenfalls Überladungen korrekt aufrufen zu können, wenn es eine int und eine Zeiger Version gibt.

 void foo (int* p){ std::cout << "*p
";}
void foo (int n){ std::cout << "n
";}
 
int main ()
{
	int* a = nullptr;
	int b = 0;
 
	foo ( a ); // gibt *p aus
	foo ( b ); // gibt n aus
	int* p = nullptr;
	int m = p; // Kompilier Fehler
	int i = nullptr; // Kompilier Fehler
}

So. Das wäre es einmal fürs erste gewesen. Hier sei auch noch gesagt, dass Visual Studio mit den gelisteten Features hinsichtlich Intellisense hevorragend auskommt. Ich (und auch sehr viele andere) sind sehr erstaunt, wie gut Intellisense jetzt funktioniert. Es macht wirklich Spass, setzt allerdings auch einen etwas leistungsfähigeren Computer voraus, wo das ganze dann noch flüssiger und schneller läuft. (Halt auch wegen der aufwendigeren Darstellung).

Ich hoffe ich konnte euch einen guten Einblick in Visual Studio 2010 geben und habe auch Neugierig auf das Produkt gemacht. Der Download der Beta ist jedem zugänglich auf der entsprechenden Microsoft Seite[1]. Natürlich hoffe ich konnte ich euch auch die Lust auf C++0x wecken. Ich persönlich kann es kaum erwarten, bis alle Features wirklich Wasserdicht in der Sprache verankert sind und die Compiler entlich das ganze implementiert haben.
Ich habe da schon so meine Idee, was ich gerne machen würde. (vor allem in Hinblick auf variadic templates, welche leider im Moment noch nicht unterstützt werden, weil sie anscheinend sehr schwer umzusetzen sind..)

Wie immer freue ich mich auf Interessante Kommentare und Berichtigung im Falle das ich einen Fehler eingebaut habe.

Ausblick:
Während meinen Recherchen bin ich auf ein paar Interessante Aspekte in C++0x gestossen, die ich mir gerne noch genauer anschauen möchte und dieser werde ich wahrscheinlich recht bald ebenfalls hier zeigen. Vor allem, weil es Features sind, welche nicht so oft genannt werden. Sozusagen die Schattenkinder von C++0x doch auch die haben so ihre interessanten Punkte.

Referenzen:
[1]Visual Studio 2010 and .NET Framework 4 Beta 2
C++0x FAQ von Bjarne Stroustrup
Visual C++ Team Blog: Visual Studio 2010 CTP released
C++09 (Teil 1) - Ein Überblick: Sprachfeatures
C++09 (Teil 2) - Ein Überblick: Die Standardbibliothek
Visual C++ Team Blog: Intellisense and Browsing with C++0x
Visual C++ Team Blog: Update on the C++-0x Language StandardKeine Kommentare | Kommentieren

Programmieren hat meist nichts mit Daemonenbeschwoerung zu tun.

- knivil -

Wobei ich so frei war und da eine Betonung gelegt habe. Keine Kommentare | Kommentieren

Mit diesem Update wird es wohl das letzte sein von Efftris. Ich habe jetzt ein paar neue Features eingebaut, wie:

• Pause
  
• restart
  
• den ominösen fehlenden block (die umgekehrte L)
  
• schnelles runter lassen der Blöcke kann wieder gestoppt werden.
  

Das ganze ist jetzt auch einiges flüssiger und macht meiner Meinung nach noch mehr Spass.

Eine Linux Version ist auch wieder unterwegs und wird die Tage als Extra Downlaod angeboten und dann ins Gesamtpaket integriert. Wird als Update in diesem Beitrag erscheinen.
Also für die, die es mit Wine versuchen, muss ich leider vorerst enttäuschen, da es mit EIFFEL_VISION Probleme und Wine zusammen Probleme zu geben scheint. Einfach noch kurz auf die Linux Version warten und alles ist gut.

Download gibts wie immer hier

readme - Wenigstens hier
Achja. Und an alle, die mit Ehrfurcht die Highscores anschauen. Es ist möglich so viele Punkte zu machen. An die, dies noch nicht gemerkt haben habe ich ein interessantes Punktesystem. Wenn man ein Tetris (4 Reihen) hat, dann bekommt man 1.5 mal so viele Punkte, wie man schon hat. Also je nachdem gibt das einen rechten push. Sparen der Reihen lohnt sich auch, auch wenn das gefährlich ist. Die richtige Balance zu finden ist die Herausforderung und machen den wahren Meister aus! (Eine Portion Glück gehört natürlich auch dazu)

Und da ja niemand die readme liest. Mit F2 könnt ihr ein Spiel neu starten und mit P schaltet ihr den Pausenmodus ein. Mit einmaligem drücken der Space Taste fällt ein Block schneller und mit nochmaligem drücken der Space Taste fällt er wieder mit der Ursprungsgeschwindigkeit.

Bei Fragen oder Nebenwirkungen (Problemen) kontaktieren sie die readme.txt. Die heisst nicht ohne Grund so.

So. Nun wünsche ich wie immer viel Spass mit dem Spiel und keine Angst. Es werden bald wieder "normale" Beiträge folgen. (Ich habe schon ein paar Ideen)

/Update
Ging schneller, als ich dachte, darum gibst die Linux Version mit im Paket oder aber auch als einzelner download hier. 2 Kommentare | Kommentieren

Da ich das Spiel als mein grösseres Projekt abgeben kann, habe ich beschlossen den Code ein wenig zu überarbeiten und noch ein wenig an den Einstellungen zu spielen. Nun kann man einiges mehr Punkte machen und es wird auch nicht so schnell soo schwer.
Um das ganze aber doch noch ein wenig interessanter zu machen, habe ich einen Online Highscore eingebaut. Nun könnt ihr euch gegenseitig bekämpfen.

Was den Source anbelangt gebe ich immer noch (fast) alles mit. Bis auf einen kleinen Teil, was für die Kommunikation mit dem Server verantwortlich ist. Kompilieren kann man das Spiel eigentlich immer noch, allerdings gibts dann keinen Online Highscore. Für die Leute, die es aber für eine andere Plattform anbieten möchten, können mich doch bitte kurz anschreiben, dann werde ich die fehlende Implementierung nachreichen. (Ansonsten wäre das ohne Obfuscating nicht wirklich vor Manipulation geschützt. Sicher ist es natürlich immer noch nicht, aber ich denke die Schwelle hat sich dadurch doch ein wenig erhöt. )

Zu erreichen ist das Paket neu hier: (der alte liefert die erste Version)

/Update:
Die Highscores sind nun auch auf dieser Seiter ersichtlich. Dieser Link ist auch im Untermenü Efftris bei den Games zu finden. Dort wird dann auch das Projekt als Übersicht dargestellt werden.

/Update:
Das Problem mit der Manipulierbarkeit sollte jetzt behoben sein. Eine Garantie gibts natürlich immer noch nicht. 3 Kommentare | Kommentieren