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.
