Primitive Built-in Types

Variables

Compound Types

const Qualifier

Dealing with Types

As programs get more complicated, using types also gets more complicated.
Two different ways:

• Hard to "spell"
  • Forms are tedious and error-prone to write
  • Forms obscure the types' purpose or meaning
• Hard to determine the exact type we need

Type Aliases

Traditionally, we use a typedef:

typedef double wages;
typedef wages base, \*p;

The keyword typedef may appear as a part of the base type of a declaration. Declarations that include 'typedef' define type aliases rather than variables. The declarators can include type modifiers, too.
The C++ 11 way, alias declaration:
using SI = Sales_item

Pointers, const, and Type Aliases

  typedef char \*pstring;
  const pstring cstr = 0; // cstr is a constant pnt to char
  const pstring \*ps; // ps is a pnt to a constant pnt to char

It can be tempting, albeit incorrect, to intepret a declaration that uses a type alias by conceptually replacing the alias with its corresponding type:
const char *cstr = 0; //wrong intepretation of const pstring cstr

The auto Type Specifier

Deduce the type of vars from the initializers. A var that uses auto as its type specifier must have an initializer.
A declaration can involve only a single base type. So the initializers for all vars in the declaration must have types that are consistent with each other.

Compound Types, const, and auto

The compiler adjusts the type to conform to normal initialization rules.

First, when using a ref as an initializer, the initializer is the corresponding object.

int i = 0, &r = i;
auto a = r; //a is an int

Second, auto ordinarily ignores top-level consts.

const int ci = i, &cr = ci;
auto b = ci; // int
auto c = cr; // int
auto d = &i; // int*
auto e = &ci; // const int*

If we want deduced type to have a top-level const, we must say so explicitly:
const auto f = ci; //deduced type of ci is int, f has a type const int
We can also specify that we want a ref to the auto-deduced type:

auto &g       = ci; // g is a const int& that is bound to ci
auto &h       = 42; // error: we can't bind a plain ref to a literal
const auto &j = 42; // ok: we can bind a const ref to a literal

When we ask for a ref to an auto-deduced type, top-level constsin the initializer are not ignored.
In a single statement, the initializers must provide consistent auto-deduced types:

auto k  = ci, &l = i; // k is int, l is int&
auto &m = ci, *p = &ci; // m is const int&, p is a pnt to const int
// error: type deduced from i is int, while type deduced from &ci is const int
auto &n = i, *p2 = &ci;

The decltype Type Specifier

Sometimes, we want to define a var with a type that the compiler deduces from an expr but don't want to use the expr to init the var.
C++ 11 feature, decltype returns the type of its operand.
decltype(f()) sum = x; // sum has the type f returns
The way decltype handles top-level const and refs differs subtly from the way auto does.
Whe the expr to which we apply decltype is a var, decltype returna the type of that var, including top-level const and refs:

const int ci = 0, &cj = ci;
decltype(ci) x = 0; // x has type const int
decltype(cj) y = x; // y is a const int& cound to x
decltype(cj) z; // error: z is a ref and must be initialized

decltype is the only context in which a var defined as a ref is not treated as a synonym for the obj to which it refers.

decltype and References

When applying decltype to an expr that isn't a var, we get the type that the expr yields. decltype returns a ref type for exprs that yield objs that can stand on the left-hand side of the assignment.
Assignment is an example of an expr that yields a ref type. The type is a ref to the type of the left-hand operand.

Defining Our Own Data Structure

Defining the Sales_data Type

struct Sales_data {
    std::string bookNo;
    unsigned units_sold;
    double revenue = 0.0;
};

Class Data Members

members, data members
C++ 11: in-class initializer
In-class initializers are restricted as to the forms we can use: They must either be enclosed inside curly braces or follow an = sign.

Using the Sales_data Class

Reading Data into a Sales_data Object

Writing Our Own Header Files

Headers usually contain entities that can be defined only once in any given file.

A Brief Introduction to the Preprocessor

The preprocessor is a program that runs before the compiler and changes the source text of our programs.
Preprocessor vars have one or two possible states: defined or not defined.
Preprocessor var names don't respect C++ scoping rules.