Skip to main content

C++ Primer Sec. 2.5 Dealing with Types

Dealing with Types

type alias

typedef double wages; // wages is a synonym for double
typedef wages base, *p; // base is a synonym for double, p for double*

C++11: alias declaration

using SI = Sales_item; // SI is a synonym for Sales_item

As usual, a const that appears in the base type modifies the given type. The type of pstring is “pointer to char.” So, const pstring is a constant pointer to char—not a pointer to const char. It can be tempting, albeit incorrect, to interpret a declaration that uses a type alias by conceptually replacing the alias with its corresponding type.

typedef char *pstring;
const pstring cstr = 0; // cstr is a constant pointer to char
const pstring *ps; // ps is a pointer to a constant pointer to char
const char *cstr = 0; // wrong interpretation of const pstring cstr

C++11: auto. auto tells the compiler to deduce the type from the initializer.

The initializers for all the variables in the declaration using auto must have types that are consistent with each other.

auto i = 0, *p = &i; // ok: i is int and p is a pointer to int
auto sz = 0, pi = 3.14; // error: inconsistent types for sz and pi

auto ordinarily ignores top-level consts, keeps low-level consts

int i = 0, &r = i;
auto a = r; // a is an int (r is an alias for i, which has type int)
const int ci = i, &cr = ci;
auto b = ci; // b is an int (top-level const in ci is dropped)
auto c = cr; // c is an int (cr is an alias for ci whose const is top-level)
auto d=&i; // d isan int*(& ofan int objectis int*)
auto e = &ci; // e is const int*(& of a const object is low-level const)
// if we want the 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 type const int
// error: type deduced from i is int; type deduced from &ci is const int
auto &n = i, *p2 = &ci;

The decltype type specifier

C++11: decltype, which returns the type of its operand. The compiler analyzes the expression to determine its type but does not evaluate the expression

decltype(f()) sum = x; // sum has whatever type f returns

decltype returns the type of that variable, including top-level const and references

const int ci = 0, &cj = ci;
decltype(ci) x = 0; // x has type const int
decltype(cj) y = x; // y has type const int& and is bound to x
decltype(cj) z; // error: z is a reference and must be initialized
// decltype of an expression can be a reference type int i = 42, *p = &i, &r = i;
decltype(r + 0) b; // ok: addition yields an int; b is an (uninitialized) int
decltype(*p) c; // error: c is int& and must be initialized
// decltype of a parenthesized variable is always a reference
decltype((i)) d; // error: d is int& and must be initialized
decltype(i) e; // ok: e is an (uninitialized) int

Comments

Post a Comment

Popular posts from this blog

C++ Primer Sec. 2.6 Defining our own data structures

Defining our own data structures Class definition must have ; at the end. Preprocessor The most common technique for making it safe to include a header multiple times relies on the preprocessor. #include Header guards #ifndef SALES_DATA_H #define SALES_DATA_H #include struct Sales_data { std::string bookNo; unsigned units_sold = 0; double revenue = 0.0; }; #endif SALES_DATA_H can be any name, just it has to be unique throughout the program. preprocessor variables usually are written in all uppercase.
Post a Comment
Read more

C++ Primer Sec.2.4 const qualifier

const Qualifier Because we can’t change the value of a const object after we create it, it must be initialized just as reference const int i = get_size(); // ok: initialized at run time const int j = 42; // ok: initialized at compile time const int k; // error: k is uninitialized const when we use an object to initialize another object, it doesn’t matter whether either or both of the objects are consts. int i = 42; const int ci = i; // ok: the value in i is copied into ci int j = ci; // ok:the value in ci is copied into j By Default, const Objects Are Local to a File When we really need to share const between files, define a single instance of a const variable, we use the keyword extern on both its definition and declaration(s). // file_1.cc defines and initializes a const that is accessible to other files extern const int bufSize = fcn(); // file_1.h extern const int bufSize; // same bufSize as defined in file_1.cc References to const const int ci = 102...
Post a Comment
Read more