C++11: Der Leitfaden für Programmierer zum neuen Standard

Cpp11DerLeitfadenFürProgrammiererZumNeuenStandard

Beschreibung:

C++11 ist der neue C++ Standard, der unmittelbar vor der Verabschiedung steht. C++11 macht den C++-Programmierer fit für die Zukunft. Dies umfasst Themen wie Threading, Funktionale Programmierung, automatisches Speichermanagement, reguläre Ausdrücke ..., um nur ein paar zu nennen.

Bjarne Stroustrup, der Erfinder von C++, bringt es kurz und prägnant auf den Punkt: C++11 feels like a new language
In diesem Buch lernen Sie C++11 kennen und insbesondere anwenden. Aufbauend auf vielen Beispielen führt es in die vielen neuen Features ein, um die anspruchsvolleren C++-Anwendungen zu meistern. Nach der Lektüre des Buches werden Sie C++ auf einem höheren Level anwenden können und C++ Code schreiben, der performanter, stabiler und wartbarer ist.

About:

Broschiert: 560 Seiten
Verlag: Addison-Wesley, München; Auflage: 1 (14. Dezember 2011)
Sprache: Deutsch
ISBN-10: 3827330882
ISBN-13: 978-3827330888

Weiterführende Informationen:

Die gibt es natürlich direkt beim Verlag. Diese umfasst

das Inhaltsverzeichnis
einen 40-seitigen Buchauszug
alle Beispiele
die Lösungen der Übungsaufgaben

Kritik:

Buch-Tipp: C++11 auf MSDN Aktuell|MSDN Online
helmut z auf Amazon:
- "Dieses Buch richtet sich an C++-Programmierer, die sich mit dem neuen Standard vertraut machen möchten" steht auf der Rückseite des Buches. Genau aus diesem Grund habe ich das Buch gekauft, und genau dieses Ziel wird mit dem Buch erreicht. Das Lesen des Buchs macht mir Freude. Der Autor ist nicht der Versuchung erlegen, ein Einführungsbuch in C++ zu schreiben und mit ein paar C++2011 Features zu garnieren. Das Buch setzt fundierte C++ Kenntnisse voraus und beschreibt zuerst in einem Überblick und dann im Detail, welche Änderungen und Erweiterungen der neue Standard bringt.
Maik Schmidt in c't 04/2012
- "...Wer C++ schon kennt, muss also nur die neuen Dinge lernen und genau diese Neuerungen präsentiert Grimm in seinem Buch. Für die ganz Unbeduldigen erklärt Grimm auf den ersten hunderten Seiten das Wichtigste im Schnelldurchlauf. Wer nur einen Überblick benötigt, wird hier schon bestens bedient. Danach beschreibt der Autor die Neuerungen detailiiert und beginnt mit dem Sprachkern. ...

Errata:

Seite 48: (Haluk Erce Rodopman)

Listing 3.11:


#include <cmath>
#include <iostream>
 
class MyHour{
  int myHour_;
  public:
 
    // constructor validating the data
    MyHour(int hour){
      if (0 <=hour and  (hour<=23)) myHour_=  hour;
      else myHour_=0;
      std::cout << "myHour_= "  << myHour_ << std::endl;
    }
 
    // default constructor for setting hour to  0
    MyHour(): MyHour(0){};
 
    // accept also doubles
    MyHour(double hour):MyHour( static_cast<int>(ceil(hour))) {};
 
};
 
int main(){
 
  // use the validating constructor
  MyHour(10);           // hour=  10
 
  // use the validating constructor
  MyHour(100);          // hour=  0
 
  // use the default constructor
  MyHour();             // hour=  0
 
  // use the constructor accepting  doubles
  MyHour(22.45);        // hour=  23
 
}

Seite 49: (Luc Deknock)

Listing 3.12:

#include <iostream>
#include <string>

class Base{
        public:
        
        Base()= default;
        
        Base(int i){
                std::cout << "Base::Base("<< i << ")" << std::endl;
        }
        
        Base(std::string s){
                std::cout << "Base::Base("<< s << ")" << std::endl;
        }
};

class Derived: public Base{
        public:
        
        using Base::Base;
        
        Derived(double d){
                std::cout << "Derived::Derived("<< d << ")" << std::endl;
        }
        
};

int main(){
        
        // inheriting Base
        Derived(2011);         // Base::Base(2011)
        
        // inheriting Base     // Base::Base(C++0x)
        Derived("C++0x");
        
        // using Derived
        Derived(0.33);         // Derived::Derived(0.33)
        
}

Seite 50/51:

Listing 3.13:


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

struct ClassMemberInitializer{
  
    ClassMemberInitializer()= default;

    ClassMemberInitializer(int override):x(override){};

    //valid with C++98
    const static int oldX=5;

    // valid with C++11
    int x=5; //class member initializer

    // valid with C++11
    std::string s="Hello C++0x";

    // valid with C++11
    std::vector<int> myVec{1,2,3,4,5};

};


int main(){

    std::cout << "\n";

    // class member initialization
    ClassMemberInitializer cMI;
    std::cout << "cMI.oldX " << cMI.oldX << "\n";     // 0
    std::cout << "cMI.x " << cMI.x << "\n";           // 5
    std::cout << "cMI.s " << cMI.s << "\n";           // Hello C++0x
    for (auto vec: cMI.myVec) std::cout << vec << " ";  // 1 2 3 4 5

    std::cout << "\n";

    // class member initialization
    // x will be overriden by the constructor value
    ClassMemberInitializer cMI2(10);
    std::cout << "cMI2.oldX " << cMI2.oldX << "\n";   // 0
    std::cout << "cMI2.x " << cMI2.x << "\n";         // 10
    std::cout << "cMI2.s " << cMI2.s << "\n";         // Hello C++0x
    for (auto vec: cMI2.myVec) std::cout << vec << " ";  // 1 2 3 4 5 

    std::cout << "\n\n";

}

Seite 126/127: (Dominik Nussbaumer)
- Listing 6.7: Zeile 28 s/const std::vector<int>&/std::vector<int>/
- Zeile 31 s/const std::vector<int>&/std::vector<int>&/

Seite 152 und 153: (7.1.3 Vererbung von Konstruktoren)
- Der Kopier-, Move- und der Standard-Konstruktor werden nicht geerbt.
- Die abgeleitete Klasse erbt nicht nur die Konstruktoren, sondern auch deren Charakteristiken. Dies betrifft die Zugriffsbeschränkungen public, protected oder privat und dessen Deklaration als explicit bzw. constexpr Konstruktor.
Seite 230-234:(10.7 Benutzerdefinierte Literale)
- Syntax: <built-in Literal>+ _ + <Suffix> (Suffixe ohne Unterstrich _ sind für den Compiler reserviert)
- Literal-Operator: <returntype> operator"" _<Suffix> (Space zwischen "" und Unterstrich)
Seite 272:
- Listing 15.4: std::mutex m muß vor der Funktion definiert werden.

Seite 284/285: (Titus von Boxberg)

Listing 15.16:

class MySingleton{
private: 
  static MySingleton* instance; 
  static std::once_flag initInstanceFlag; 
  static void initInstance(){      
    instance= new MySingleton();    
}    
MySingleton()= default;    
~MySingleton()= default;  
public:    
  MySingleton(const MySingleton&)= delete;    
  MySingleton& operator=(const MySingleton&)= delete;    
  static MySingleton& getInstance();  
};  

std::once_flag MySingleton::initInstanceFlag;  
MySingleton* MySingleton::instance= nullptr;  
MySingleton& MySingleton::getInstance(){    
  std::call_once(initInstanceFlag,&MySingleton::initInstance);  
    return *instance;  
}

Seite 337:
- Tabelle 19.8 (smatch.prefix()): Gib ein sub_match Objekt zurück, das die Zeichenkette vor dem Suchergebnis (smatch[0]) referenziert.
- Tabelle 19.8 (smatch.suffix()): Gib ein sub_match Objekt zurück, das die Zeichenkette nach dem Suchergebnis (smatch[0]) referenziert.
Seite 464/465: (Norbert Eichenseher)
- newAlgorithmen.cpp(Zeile 10,30 und 31): s/return (i % 2)/return (i % 2) == 0;/
- newAlgorithmen.cpp(Zeile 52): s/std::back::inserter(allOdd),std::back_inserter(allEven)/std::back::inserter(allEven),std::back_inserter(allOdd)/