The C++ Programming Language Notes

1.3.1

1.6.1 Suggestions for C Programmers

1.8 Advice

2.5.4 Abstract Types

class Stack{
public:
  virtual void push(char c) = 0;
  virtual char pop() = 0;
};

2.7.1 Containers

3.5.1 CStyle Strings

3.7 Containers

• 3.7.3 List
  

  Every standard library container provides the functions begin() and end(), which return an iterator to the first and to one-past-the-last element, respectively (§16.3.2).

  When we don’t need to modify an element of the container, const_iterator is the type we want. Otherwise, we use the plain iterator type (§16.3.1).

• 3.7.5 Standard Containers
  

  Standard Container Summary
  vecotr<T> A variable-sized vector (§16.3)
  list<T> A doubly-linked list (§17.2.2)
  queue<T> A queue (§17.3.2)
  stack<T> A stack (§17.3.1)
  deque<T> A double-ended queue (§17.2.3)
  priority queue<T> A queue sorted by value (§17.3.3)
  set<T> A set (§17.4.3)
  multiset<T> A set in which a value can occur many times (§17.4.4)
  map<key,val> An associative array (§17.4.1)
  multimap<key,val> A map in which a key can occur many times (§17.4.2)
  

3.8

• 3.8.2 Iterator Types
  

  Any particular iterator is an object of some type. There are, however, many different iterator types because an iterator needs to hold the information necessary for doing its job for a particular container type. These iterator types can be as different as the containers and the specialized needs they serve.

  In fact, any object that obeys a few simple rules like these is an iterator (§19.2.1).

• 3.8.4 Traversals and Predicates
  

  bool gt_42(const pair<const string, int>& r)
  {
    return r.second > 42;
  }
  
  void g(const map<string, int>& m)
  {
    int c42 = conunt_if(m.begin(), m.end(), gt_42);
  }
  

  A function, such as gt₄₂(), that is used to control the algorithm is called a predicate. A predicate is called for each element and returns a Boolean value, which the algorithm uses to perform its intended action.

  void g(list<Shape *>& sh)
  {
    for_each(sh.begin(), sh.end(), mem_fun(&Shape::draw));
  }
  

  The standard library mem_fun() template (§18.4.4.2) takes a pointer to a member function (§15.5) as its argument and produces something that can be called for a pointer to the member’s class. The result of mem_fun (&Shape::draw) takes a Shape * argument and returns whatever Shape::draw() returns.

• 3.8.6 Standard Library Algorithms
  

  The algorithms are defined in namespace std and presented in the <algorithm> header. Here are a few I have found particularly useful:

   Selected Standard Algorithms
  for_each() Invoke function for each element (§18.5.1)
  find() Find first occurrence of arguments (§18.5.2)
  find_if() Find first match of predicate (§18.5.2)
  count() Count occurrences of element (§18.5.3)
  count_if() Count matches of predicate (§18.5.3)
  replace() Replace element with new value (§18.6.4)
  replace_if() Replace element that matches predicate with new value (§18.6.4)
  copy() Copy elements (§18.6.1)
  unique_copy() Copy elements that are not duplicates (§18.6.1)
  sort() Sort elements (§18.7.1)
  equal_range() Find all elements with equivalent values (§18.7.2)
  merge() Merge sorted sequences (§18.7.3)
  

3.11 Advice

4.2 Booleans

4.3 Character Types

• 4.3.1 Character Literals
  

  Wide character literals are of the form L´ab´, where the number of characters between the quotes and their meanings is implementation-defined to match the wchar_t type.

4.4 Integer Types

• 4.4.1 Integer Literals
  

  The suffix U can be used to write explicitly unsigned literals. Similarly, the suffix L can be used to write explicitly long literals. For example, 3 is an int , 3U is an unsigned int , and 3L is a long int.

• 4.5.1 Floating-Point Literals
  

  By default, a floating-point literal is of type double.

  If you want a floating-point literal of type float, you can define one using the suffix f or F :

  3.14f 2.0f 1.99F

4.6 Sizes

#include <limits>

int main()
{
  cout << "largest float == " << numeric_limits<float>::max()
       << ", char is signed == " << numeric_limits<char>::is_signed << '\n';
}

4.8 Enumerations

enum e1 { dark, light };          //range 0:1
enum e2 { a = 3, b = 9 };         //range 0:15
enum e3 { min = -10, max = 1000000 }; //range: -1048576:1048575

enum flag { x = 1, y = 2, z = 4, e = 8 }; //range 0:15
flag f1 = 5;   //type error: 5 is not of type flag
flag f2 = flag(5); //ok: flag(5) is of type flag and within the range of flag

4.9

• 4.9.1 The Structure of a Declaration
  

  The postfix declarator operators bind tighter than the prefix ones. Consequently, *kings[] is a vector of pointers to something, and we have to use parentheses to express types such as ‘‘pointer to function;’’

• 4.9.4 Scope
  

  A hidden global name can be referred to using the scope resolution operator ::.

  int x;
  
  void f2()
  {
    int x = 1; //hide global x
    ::x = 2;  //assign to globlal x
    x = 2;   //assign to local x
  }
  

• 4.9.5 Initialization
  

  If no initializer is specified, a global (§4.9.4), namespace (§8.2), or local static object (§7.1.2, §10.2.4) (collectively called static objects) is initialized to 0 of the appropriate type.

• 4.9.6 Objects and Lvalues
  

  That is, an object is a contiguous region of storage; an lvalue is an expression that refers to an object.

4.10 Advice

5.1 Pointers

• 5.1.1 Zero
  

  Zero (0) is an int. Because of standard conversions (§C.6.2.3), 0 can be used as a constant of any integral (§4.1.1), floating-point, pointer, or pointer-to-member type. The type of zero will be determined by context.

  In C, it has been popular to define a macro NULL to represent the zero pointer. Because of C++’s tighter type checking, the use of plain 0 , rather than any suggested NULL macro, leads to fewer problems.

5.2 Arrays

void f(int i)
{
  int v1[i];     //error: array size not a constant expression
  vector<int> v2[i]; // ok
}

• 5.2.1 Array Initializers
  

  If the initializer supplies too few elements, 0 is assumed for the remaining array elements. For example:

  char v5[8] = { 1, 2, 3, 4};
  is equivalent to
  char v5[8] = { 1, 2, 3, 4, 0, 0, 0, 0};
  

• 5.2.2 String Literals
  

  Whether two identical character literals are allocated as one is implementation-defined. For example:

  const char* p = "Heraclitus";
  const char* q = "Heraclitus";
  
  void g()
  {
    if(p == q) cout<< "one \n"; //result is implementation-defined
    //..
  }
  

  The empty string is written as a pair of adjacent double quotes, "", (and has the type const char[1]).

  A string with the prefix L, such as L"angst" , is a string of wide characters (§4.3, §C.3.3). Its type is wchar_t[].

5.3 Pointers into Arrays

• 5.3.1 Navigating Arrays
  

  This implies that the integer value of p+1 will be sizeof(T) larger than the integer value of p .

5.4 Constants

• 5.4.1 Pointers and Constants
  

  ‘‘Prefixing’’ a declaration of a pointer with const makes the object, but not the pointer, a constant. To declare a pointer itself, rather than the object pointed to, to be a constant, we use the declarator operator *const instead of plain *.

  The declarator operator that makes a pointer constant is *const. There is no const * declarator operator, so a const appearing before the * is taken to be part of the base type. For example:

  char *const cp;     //const pointer to char
  char const* pc;     //pointer to const char
  const char* pc2;    //pointer to const char
  

  Some people find it helpful to read such declarations right-to-left. For example, ‘‘cp is a const pointer to a char ’’ and ‘‘pc2 is a pointer to a char const.’’

5.5 References

double& dr = 1;          //error: lvalue needed
const double& cdr = 1;   //ok

The interpretation of this last initialization might be:

double temp = double(1);  //first create a temporary with the right value
const double& cdr = temp; //then use the temporary as the intializer for cdr

5.7 Structures

struct Link{
  Link* previous;
  Link* successor;
};

struct No_good{
  No_good member;  //error: recursive definition
};