Chapter 2 Variables and Basic Types

2.3 Variable

• key Concept: Strong Static Typing

C++ is a statically typed language, which means that types are checked at compile time. In C++, whether an operation is legal or not is checked at compile time. A consequence of static checking is that the type of every entity used in our programs must be known to the compiler.

2.3.1 what is a variable?

A variable provides us with named storage that our programs can manipulate.

1. Each variable in C++ has following items:

• The Specific type: determine the size and layout of the variable’s memory
• The range of values: that can be stored in the memory.
• The set of operations: that can be applied to the variable

2. lvalue and rvalue

• lvalue: an expression that is an lvalue may appear as either the left-hand or right-hand side of an assignment.
• rvlaue: An expression that is an rvalue may appear on the right- but not left-hand side of an assignment.

2.3.2 The Name of a Variable

·         Identifier: The Name of a variable.

·         In C++, identifier are case-sensitive

·         It must begin with either a latter or an underscore.

·         In addition to the keywords, the standard also reserves a set of identifiers for use

in the library. Identifiers cannot contain two consecutive underscores, nor can an identifier begin with an underscore followed immediately by an upper-case letter.

1. C++ keywords

2. C++ operator alternative names

2.3.3 Defining Objects

Each definition starts with a type specifier, followed by a comma-separated list of one or more names. A semicolon terminates the definition.

Multiple variables may be defined in a single statement.

1. Variable Initialization: a definition specifies a variable’s type and identifier. In addition, it may also provide an initial value. Tow forms of variables initialization: copy-initialization and direct-initialization.
1. direct-initialization

               int ival(1024);     // direct-initialization

2. copy-initialization

int ival = 1024;    // copy-initialization

2. initialization and assignment are different operations in C++
3. the different between initialization and assignment

Initialization happens when a variable is created and gives that variable its initial value. Assignment involves obliterating an object's current value and replacing that value with a new one.

4. There are subtle differences between copy- and direct-initialization when initializing objects of a class type. We won't completely explain these differences until Chapter 13. For now, it's worth knowing that the direct syntax is more flexible and can be slightly more efficient.

2.3.4. Variable Initialization Rules

When we define a variable without an initializer, the system sometimes initializes the variable for us. What value, if any, is supplied depends on the type of the variable and may depend on where it is defined.

• Initialization of Variables of Built-in type

o        Global variables are initialized to zero

o        Local variables are unitialized

o        Using an uninitialized variable for anything other than as the left-hand operand of an assignment is undefined

o        We recommend that every object of built-in type be initialized. It is not always necessary to initialize such variables, but it is easier and safer to do so until you can be certain it is safe to omit an initializer.

• Initialization of Variables of Class type

o        Classes control object initialization by defining one or more constructors, even the system special constructor, known as the default constructor.

o        The default constructor is used regardless of where a variable is defined.

o        Most classes provide a default constructor. If the class has a default constructor, then we can define variables of that class without explicitly initializing them.

o        Some class types do not have a default constructor. For these types, every definition must provide explicit initializer(s). It is not possible to define variables of such types without giving an initial value.

2.3.5 Declarations and Definitions

• Definition

A definition of a variable allocates storage for the variable and may also specify an initial value for the variable. There must be one and only one definition of a variable in a program.

• declaration

a declaration makes known the type and name of the variable to the program. A definition is also a declaration.

When we define a variable, we declare its name and type. We can declare a name without defining it by using the extern keyword. A declaration that is not also a definition consists of the object's name and its type preceded by the keyword extern:

• examples

        extern int i;   // declares but does not define i

        int i;          //  declares and defines i

        extern double pi = 3.1416; // definition

Despite the use of extern, this statement defines pi. Storage is allocated and initialized. An extern declaration may include an initializer only if it appears outside a function.

Any variable that is used in more than one file requires declarations that are separate from the variable's definition. In such cases, one file will contain the definition for the variable. Other files that use that same variable will contain declarations forbut not a definition ofthat same variable.

2.3.6 Scope of a Name

A scope is a region of the program. A name can refer to different entities in different scopes.

• Global Scope

Names defined outside any function have global scope; they are accessible from anywhere in the program.

• Local Scope

Names defined in any function. It is accessible throughout the function but not outside of it.

• Statement Scope

It can be used in that statement but not elsewhere in main.

• Class Scope
• Namespace Scope

Scopes in C++ Nest

• Names defined in the global scope can be used in a local scope;
• Global names and those defined local to a function can be used inside a statement scope.
• Names can also be redefined in an inner scope
• The variable defined in the inner scope will hide the variable defined in outer scope, if they have the same name
• It recommend that using different name between global variable(outer variable) and local variable(inner variable).

Examples

Best Priactise

• Defining an object where the object is first used improves readability
• Moreover, it is often easier to give the variable a useful initial value when the variable is defined close to where it is first used.

2.4 Const

The const type qualifier provides a solution: it transforms an object into a constant.

const double pi = 3.14;

• the const variable is still an lvalue, but the lvalue is unmodifiable.

        bufSize = 0; // error: attempt to write to const object

• We must initialize the const variable when it is defined, because we cann’t subsequently change the value of an object declared to be const.

        const std::string hi = "hello!"; // ok: initialized

        const int i, j = 0;  // error: i is uninitialized const

• const Objects Are Local to a File By Default

Unlike other variables, unless otherwise specified, const variables declared at global scope are local to the file in which the object is defined. The variable exists in that file only and cannot be accessed by other files.

• We can make a const object accessible throughout the program by specifying that it is extern:

// file_1.cc

      // defines and initializes a const that is accessible to other files

      extern const int bufSize = fcn();

      // file_2.cc

      extern const int bufSize; // uses bufSize from file_1

      // uses bufSize defined in file_1

      for (int index = 0; index != bufSize; ++index)

Note:

2.5 Reference

A reference serves as an alternative name for an object. In real-world programs, reference are primarily used as formal parameter to functions.

• Defining Multiple References

We can define multiple references in a single type definition. Each identifier that is a reference must be preceded by the & symbol. The usage of defining multiple references is similar to defining multiple pointers.

        int i = 1024, i2 = 2048;

        int &r = i, r2 = i2;      // r is a reference, r2 is an int

        int i3 = 1024, &ri = i3;  // defines one object, and one refer

        int &r3 = i3, &r4 = i2;   // defines two references

• A reference is an alias

Because a reference is just another name for the object to which it is bound, all operations on reference are actually operations on the underlying object to which the reference is bound. We can access a variable either through its actual name or through its alias.

• you must initialize a reference when you define it; initialization is the only way to say to which object a reference refers
• A reference must be initialized using an object of the same type as the reference.
• When a reference is initialized, it remains bound to that object as long as the reference exists. There is no way to rebind a reference to a different object.

Note: const reference V.S non-const reference

• A const reference is a reference that may refer to a const object.
• A non-const reference is a reference that must refer to non-const object. It can’t refer to an const object
• A const reference can be initialized to an object of a different type or to an rvalue, such as a literal constant.
• A  none-const reference must refer to the same type as the reference. And it can’be initialized by an rvalue, literal constant.

        double dval = 3.14;

        const int &ri = dval;

the compiler transforms this code into something like this:

        int temp = dval;         // create temporary int from the double

        const int &ri = temp;   // bind ri to that temporary

Examples

Question?

What are the differences among the definitions in (a) and the assignments in (b)? Which, if any, are illegal?

     (a) int ival = 0;          (b) ival = ri;

         const int &ri = 0;         ri = ival;

2.6 Typedef

A typedef lets us define a synonym for a type. The identifier, or typedef name, does not introduce a new type but rather a synonym for the existing data type.

Typedefs are commonly used for one of three purposes:

• To hide the implantation of a given type and emphasize instead the purpose for which the type is used.
• To streamline complex type definitions, making them easier to understand.
• To allow a single type to be used for more than one purpose while making the purpose clear each time the type is used.

Examples

2.7 Enumerations

• Enumerations provide an alternative method of not only defining but also grouping sets of integral constants.
• Enumerators are const Values.
• We may supply an initial value for one or more enumerators. The value used to initialize an enumerator must be a constant expression. A constant expression is an expression of integral type that the compiler can evaluate at compile time
• By default, the first enumerator is assigned the value zero. Each subsequent enumerator is assigned a value one greater than the value of the enumerator that immediately precedes it.

Examples

2.8 Class Types

Each class defines an interface and implementation.

• The interface consists of the operations that we expect code that uses the class to execute.
• The implementation typically includes the data needed by the class. The implementation also includes any functions needed to define the class but that are not intended for general use.

Note: the differences between Class and Struct

2.9 Head Files

Proper use of head files can provide two benefits:

• All files are guaranteed to use the same declaration for a given entity;
• If a declaration requires change, only the header needs to be updated;

When designing a header it is essential to remember the difference between definitions, which may only occur once, and declarations, which may occur multiple times

Beware: which should be included in the head files

• Because headers are included in multiple source files, they should not contain definitions of variables or functions.
• There are three exceptions to the above rule that headers should not contain definitions: classes, const objects whose value is known at compile time, and inline functions  covers inline functions) are all defined in headers
• These entities are defined in headers because the compiler needs their definitions (not just declarations) to generate code. For example, to generate code that defines or uses objects of a class type, the compiler needs to know what data members make up that type. It also needs to know what operations can be performed on these objects. The class definition provides the needed information. That const objects are defined in a header may require a bit more explanation.

Generally speaking, a constant expression is an expression that the compiler can evaluate at compile-time

Avoiding Multiple Inclusions

A common way to make headers safe uses the preprocessor to define a header guard. The guard is used to avoid reprocessing the contents of a header file if the header has already been seen.

        #ifndef SALESITEM_H

        #define SALESITEM_H

        // Definition of Sales_itemclass and related functions goes here

        #endif

Best Practices

• Headers should have guards, even if they aren't included by another header.
• The conditional directive usually are written in all uppercase letters
• If the head files are changed, all files including the head files should be recompiled.

Using head files

• Standard header: The compiler will look for it in a predefined set of locations, which can be modified by setting a search path environment variable or through a command line option
• User Header files: The search for nonsystem headers usually begins in the directory in which the source file is located

        #include <standard_header> // standard header

        #include "my_file.h"   // user header

发表于 @ 2007年10月30日　22:13:00 | 评论( loading... ) | 编辑| 举报| 收藏