Category:C++

The following is my set of recommendations and tips for C++ programmers. I have tried to conform to de facto standards.

General

 * The C++ Standards Committee
 * MSDN Standard C++ Library Overview
 * C++ Reference Manual - strings and stuff
 * Marshall Cline's C++ FAQ
 * cplusplus.com tutorial with lots of code examples
 * C++ Operator Precedence
 * Bruce Eckel's Thinking in C++ volume 1
 * Bruce Eckel's Thinking in C++ volume 2
 * OOPWeb: Free C++ Books
 * The GNU Build System - autoconf and automake
 * Doxygen Command Reference

Generic Programming (templates)

 * boost.org: Generic Programming Techniques - good introduction
 * Standard Template Library Introduction (STL table of contents)
 * genericprogramming.org
 * Boost Libraries

Interesting Videos

 * Bjarne Stroustrup: C++0x Initialization Lists
 * Douglas Gregor: Concepts Extending C++ Templates For Generic Programming
 * Lawrence Crowl: New Features in the Next C++ Standard

Integrated Development Environment (IDE)'s

 * Dev-C++: C++ IDE for win32
 * Code::Blocks: cross-platform C++ IDE

Programming Paradigms

 * procedural programming: functions and arguments
 * modular programming: partition program into modules
 * = data hiding, encapsulation
 * division into interface, representation and implementation
 * enables separate compilation of implementation of a module and another module using the module, via an interface
 * namespaces in C++ provide data hiding
 * data abstraction: the enforcement of a clear separation between the abstract properties of a data type and the concrete details of its implementation.
 * user-defined types
 * concrete types (may be instantiated)
 * abstract types (may be derived from, defines an interface)
 * a polymorphic class provides the interface to a variety of other classes
 * member functions may be virtual, so that they may be redefined in an implementation
 * when a member function is invoked on an object derived from a polymorphic class, the function is looked up in a virtual function table (the object contains a pointer to the correct virtual function table) and invoked
 * object-oriented programming
 * capture commonalities by using inheritance
 * generic programming: parameterization of general classes and algorithms

General C++ Vocabulary

 * External linkage:a name that can be used in translation units different from the one in which it was defined. Variables, classes, and functions have external linkage by default, s and  s have internal linkage by default.
 * Implicit type conversion:non-explicit casting between built-in types, e.g.
 * Lvalue: An expression that refers to an object
 * Object: A contiguous region of storage
 * Overloading: using the same name for operations on different types
 * Policy:A policy class is a template parameter used to transmit behavior.
 * Polymorphism: the use of a general interface to manipulate things of various specialized types. The concept of polymorphism applies to both data types and functions. A function that can evaluate to or be applied to values of different types is known as a polymorphic function. A data type that can appear to be of a generalized type is known as a polymorphic data type as is the generalized type from which such specializations are made. Virtual functions provide run-time polymorphism and templates provide compile-time polymorphism.
 * Rvalue: an expression that is not an lvalue.
 * Standard conversion:
 * Static:A member that is part of a class, yet is not part of an object of that class. A static member function doesn't need to be invoked for an object of the class.
 * Template instantiation:generating a class declaration from a template class and a template argument
 * Template specialization:a version of a template for a particular template argument
 * Traits:In computer programming, a trait class is a template class used to associate information or behaviour to a value or an existing data type.
 * Translation unit:The result of preprocessing a source file.
 * Type safe:
 * Virtual function:A function that allows derived classes to replace the implementation provided by the base class. The compiler makes sure the replacement is always called whenever the object in question is actually of the derived class, even if the object is accessed by a base pointer rather than a derived pointer. A pure virtual function is a virtual function without an implementation, and if it isn't replaced in a derived class, the class becomes abstract.
 * Vtable:A table of pointers to all virtual member functions in a class.
 * vptr:Pointer in object to the Vtable of the corresponding class. Even if the object is accessed by a base pointer, the vptr points to the Vtable of the derived class.