Something about C/C++

Notice:I am learning C++ and I write down this artical just want to prevent me form forgetting.Reproduced,please indicate the source! 

With the exception of static const int data members , a class’s data members cannot be initialized where they’re declared in the class body.

Objects contain only data, so objects are much smaller than if they also contained member functions. Applying operator sizeof to a class name or to an object of that class will report only the size of the class’s data members. The compiler creates one copy (only) of the member functions separate from all objects of the class. All objects of the class share this one copy.
Each object, of course, needs its own copy of the class’s data, because the data can vary among the objects. The function code is nonmodifiable and, hence, can be shared among all objects of one class.

 

---

 Char 

2013-04-25  11:41:01

    char a,b,c;
    a='a';
    b='\x61';//Hexadecimal.
    c='\141';//Octonary.
    printf("%d\ ",(unsigned int)a);
    printf("%d\ ",(unsigned int)b);
    printf("%d\ ",(unsigned int)c);
    //output:97 97 97

#include <stdio.h>
 
 int main()
 {
     unsigned char uc;
     char c;
     uc = 0x81;
     c = uc;
     printf("c=%d\n",c);//-127
     printf("uc=%d\n",uc);//129
 
     //sign extension with '1'
     printf("%x\n",(unsigned int)c);//ffffff81
     //sign extension with '0'
     printf("%x\n",(unsigned int)uc);//81
     //implicit type conversion
     printf("%x\n",(unsigned char)c);//81
 
 }

Treated as different types 

"arm-linux-gcc" treats type char as "unsigned char" and "gcc" treats it as "signed char",so the below syntax blocks will get the same result.

unsigned char DecodeProtocol(unsigned char *pu8DataRx, unsigned char *pu8Data, unsigned char *pu8Length);
//'signed char'='unsigned char' when using 'x86 gcc'.
//'unsigned char'='unsigned char' when using 'arm-linux-gcc'.
char u8RetValue = DecodeProtocol(msgBuffer,au8RxDataToRead, &u8Length);

 

---

Pointer

There are three values that can be used to initialize a pointer: 0, NULL(but in C++, 0 is used by convention) or an address of an object of the same type. The new C++ standard also provides the nullptr constant, which is preferred.The only integer that can be assigned to a pointer without casting is zero.The value 0 is the only integer value that can be assigned directly to a pointer variable without first casting the integer to a pointer type.

If a value does not (or should not) change in the body of a function to which it’s passed,the parameter should be declared const.By default, objects are passed by value—a copy of the entire object is passed. This requires the execution-time overhead of making a copy of each data item in the object and storing it on the function call stack. When a pointer to an object is passed, only a copy of the address of the object must be made—the object itself is not copied.

 Type of Void

All pointer types can be assigned to a pointer of type void * without casting. However, a pointer of type void * cannot be assigned directly to a pointer of another type—the pointer of type void * must first be cast to the proper pointer type.

So,in a function parameter,it is helpful to declare any pointer as type void.such as:

bool readFile(const char * _fileName,void * _pBuf,int _bufLen);

Then we can call this function by passing any type of pointer to it without casting.

char buf[32];
readFile(fileName,buf,sizeof(buf));

String literals

String literals have static storage class (they exist for the duration of the program) and may or may not be shared if the same string literal is referenced from multiple locations in a program. The effect of modifying a string literal is undefined; thus, you should always declare a pointer to a string literal as const char *.

char aChar[]="blue";
//this statement has the same effect with the above statement.
char aChar[]={'b','l','u','e','\0'};
//the effect of modifying a string literal is undefined,
//so you should always declare a pointer to string literal as 'const char *'.
const char * csPtr="blue";

Command-line Arguments

String arrays are commonly used with command-line arguments that are passed to function main when a program begins execution.Each pointer points to the first character of its corresponding string.

const char * const suit[4]={"Hearts", "Diamonds", "Clubs", "Spades"};
int main(int argc,char * argv[]);
int main(int argc,char ** argv);

 Selection Sort:

#include <iostream>
using namespace std;

//the first parameter can alse be declared as 'int array[]'
//the type of a array name is 'a const pointer to nonconstant type'
void selectionSort(int * const array,const int len);
void swap(int * const a,int * const b);
void printArray(int * const array,const int len);

int main()
{
    const int size=10;
    int aInt10[size]={12,32,15,6,54,73,32,75,5,50};
    printArray(aInt10,size);
    selectionSort(aInt10,size);
    printArray(aInt10,size);
}

void selectionSort(int * const array,const int len)
{
    int smallest;
    
    for(int i=0;i<len-1;++i)
        {
        smallest=i;
        for(int index=i+1;index<len;++index)
            {
            if(array[index]<array[smallest])
                {
                smallest=index;
            }
        }

        swap(&array[i],&array[smallest]);
    }
}

void swap(int * const a,int * const b)
{
    int tmp;
    tmp=*a;
    *a=*b;
    *b=tmp;
}

void printArray(int * const array,const int len)
{
    for(int index=0;index<len;++index)
        {
        cout<<array[index]<<"\t";
    }
    cout<<endl;
}

 

---

Array & Vector

Array

Arrays, structures and classes are “static” entities in that they remain the same size throughout program execution.The ISO/IEC C++ standard defines an “object” as any “region of storage.” Like objects of classes, fundamental-type variables also occupy space in memory, so they’re often referred to as “objects.”

//use initializer list to initialize array n
int n[10] = {21,42,53,74,23,64,75,97,23,43};

//If there are fewer initializers than array elements,the 
//remaining array elements are initialized to zero.
int n[10] ={};

//If the array size is omitted from a declaration with an initializer list
//the compiler sizes the array to the number of elements in the initializer list.
int n[]={1,2,3,4,5}; 

//constant variable can be used to specify array size
const int arraySize=10;
int s[arraySize]={};

void func(void)
{
    //if a static array is not initialized explicitly
    //when they are declared,each element of that array
    //is initialized to zero by the complier.But auto arrary 
    //is not.
    static int staticArray[3];
    int autoArray[3];
}

void constArgumentArray(const int b[])
{
    //array 'b' can not be modified within this 
    //function body when argument 'b' has a qualifier 'const'
}

int array1[2][3]={{1,2,3},{4,5,6}};
int array2[2][3]={1,2,3,4,5};
int array3[2][3]={{1,2},{2}};

//determine the number of elements in an array.
double aReal[10];
int nElements=sizeof(aReal)/sizeof(aReal[0]);

#include <iostream>

void insertionSort(int aInt[],int aIntSize);
void printArray(int aInt[],int aIntSize);

int main()
{
    const int aIntSize=10;
    int aInt[10]={23,43,56,87,89,56,12,56,64,71};
    printArray(aInt,10);
    insertionSort(aInt,10);
    printArray(aInt,10);    
}

void insertionSort(int aInt[],int aIntSize)
{
    int insert;
    int moveItem;
    
    for(int i=1;i<aIntSize;++i)
        {
        insert=aInt[i];
        moveItem=i;
        
        while(0<moveItem && aInt[moveItem-1]>insert)
            {
                                                //need to be attention here
            aInt[moveItem]=aInt[moveItem-1];
            --moveItem;
        }
        aInt[moveItem]= insert;
    }
}

void printArray(int aInt[],int aIntSize)
{
    for(int i=0;i<aIntSize;++i)
        {
        std::cout<<aInt[i]<<"\t";
    }
    std::cout<<std::endl;
}

When a function receives a one-dimensional array as an argument, the array brackets are empty in the function’s parameter list. The size of a two-dimensional array’s first dimension (i.e., the number of rows) is not required either, but all subsequent dimension sizes are required. The compiler uses these sizes to determine the locations in memory of elements in multidimensional arrays. All array elements are stored consecutively in memory, regardless of the number of dimensions. In a two-dimensional array,row 0 is stored in memory followed by row 1. Each row is a one-dimensional array. To locate an element in a particular row, the function must know exactly how many elements are in each row so it can skip the proper number of memory locations when accessing the array. Thus, when accessing a[1][2], the function knows to skip row 0’s three elements in memory to get to row 1. Then, the function accesses element 2 of that row.

#include <iostream>

void printDimenIntArray(int aIntDimen[][3]);

int main()
{
    int aIntDimensinal[][3]={{1,2,3},{4,5,6}};
    printDimenIntArray(aIntDimensinal);
}

void printDimenIntArray(int aIntDimen[][3])
{
    for(int i=0;i<2;i++)
        {
        for(int j=0;j<3;j++)
            {
            std::cout<<aIntDimen[i][j]<<"\t";
        }
        std::cout<<std::endl;
    }
}

 Vector

 

  

---

Function

Evaluation Order of Function Arguments

The order of evaluation of a function’s arguments,however, is not specified by the C++ standard. Thus, different compilers can evaluate function arguments in different orders. The C++ standard does guarantee that all arguments in a function call are evaluated before the called function executes.If you have doubts about the order of evaluation of a function’s arguments and whether the order would affect the values passed to the function, evaluate the arguments in separate assignment statements before the function call, assign the result of each expression to a local variable, then pass those variables as arguments to the function.

Return Control

There are three ways to return control to the point at which a function was invoked.If the function does not return a result (i.e., it has a void return type), control returns when the program reaches the function-ending right brace, or by execution of the statement "return;"If the function does return a result, the statement "return expression;"evaluates expression and returns the value of expression to the caller.

Argument Coercion

Sometimes, argument values that do not correspond precisely to the parameter types in the function prototype can be converted by the compiler to the proper type before the function is called.Converting values to lower fundamental types can result in incorrect values. Therefore,a value can be converted to a lower fundamental type only by explicitly assigning the
value to a variable of lower type (some compilers will issue a warning in this case) or by using a cast operator.

Below lists the fundamental data type from "highest type" to "lowest type".

Standard Library Headers

Header names ending in.h are “old-style” headers that have been superseded by the C++ Standard Library headers.

Some common C++ Standard Library headers are listed below:

Case Study:Game of Chance

#include <iostream>
//contain prototype for function 'rand()' &'srand()'
#include <cstdlib>
//contain prototype for function 'time()'
#include <ctime>

using namespace std;

int rollDice();

int main()
{
    //return the current time as the number of seconds since January 1,1970 at midnight GMT.
    //this is converted to an unsigned int which is used as the seed of the random number generator.
    srand(time(0));
    
    //declare a user-defined type called enumeration
    //capitalize the first letter of an identifier used as a user-defined type name.
    //using only upperletters in enumeration constant name can remind you that 
    //enumeration constants are not variable.
    enum FinalStatus{WIN,LOSS,CONTINUE};
    
    FinalStatus status;
    int sumOfDice;
    int myPoint;

    sumOfDice=rollDice();
    switch (sumOfDice)
        {
        case 7:
        case 11:
            status=WIN;
            break;
        case 2:
        case 3:
        case 12:
            status=LOSS;
            break;
        default:
            status=CONTINUE;
            myPoint=sumOfDice;
            break;
    }

    while(status==CONTINUE)
        {
        sumOfDice=rollDice();
        if(myPoint==sumOfDice)
            status=WIN;
        else if(7==sumOfDice)
            status=LOSS;
    }

    if(WIN==status)
        cout<<"you win the game"<<endl;
    else
        cout<<"you loss the game"<<endl;
    
}

int rollDice()
{
    //rand() generate an unsigned int  between 0 to RAND_MAX(a symbolic constant 
    //definded in <cstdlib> header.
    //function rand() actually generates pseudorandom numbers which repeats itself 
    //each time the program executes.
    int die1=1+rand()%6;
    
    int die2=1+rand()%6;
    cout<<"roll result:"<<die1<<"+"<<die2<<"="<<die1+die2<<endl;
    return die1+die2;
}

Inline Function

If a member function is defined in the body of a class definition, the member function is implicitly declared inline. Remember that the compiler reserves the right not to inline any function. Reusable inline functions are typically placed in headers, so that their definitions can be included in each source file that uses them.Placing the qualifier inline before a function’s return type in the function definition “advises” the compiler to generate a copy of the function’s body code in place (when appropriate) to avoid a function call.

#include <iostream>
inline double cube(double a);

int main()
{
    double x=5.1;
    std::cout<<"x^3="<<cube(x)<<std::endl;
    
}

inline double cube(double a)
{
    return a*a*a;
}

References and Reference Parameters

For passing large objects, use a constant reference parameter to simulate the appearance and security of pass-by-value and avoid the overhead of passing a copy of the large object.

#include <iostream>

using namespace std;

//A reference parameter is an alias for its coresponding argument in the function call. 
void square(int& intRef);

int main()
{
    int x=4;
    cout<<"Before func call:"<<"x="<<x<<endl;
    square(x);
    cout<<"After func call:"<<"x="<<x<<endl;

    int y=3;
    //Reference variables must be initialized in their declarations.
    //and can not be reassigned as aliases to other variables.
    int& z=y;
    cout<<"z="<<z<<endl;
}

void square(int& intRef)
{
    intRef *=intRef;
}

//output:
//Before func call:x=4
//After func call:x=16
//z=3

 Default Argument

1-When a program omits an argument for a parameter with a default argument in a function call, the compiler rewrites the function call and inserts the default value of that argument.

2-Default arguments must be the rightmost (trailing) arguments in a function’s parameter list.

3-Default arguments must be specified with the first occurrence of the function name—typically, in the function prototype,or might in the function header.

4-Default values can be any expression, including constants, global variables or function calls.

5-Default arguments also can be used with inline functions.

6-Any arguments passed to the function explicitly are assigned to the function’s parameters from left to right.

#include <iostream>

int volumn(int high=1,int width=1,int length=1);

int main()
{
    int h=10,w=10,l=10;
    std::cout<<"volumn(h):"<<volumn(h)<<std::endl;
    std::cout<<"volumn(h,w):"<<volumn(h,w)<<std::endl;
    std::cout<<"volumn(h,w,l):"<<volumn(h,w,l)<<std::endl;
}

int volumn(int high,int width,int length)
{
    return high*width*length;
}

 Unary Scope Operator

C++ provides the unary scope resolution operator (::) to access a global variable when a local variable of the same name is in scope.

Using the unary scope resolution operator (::) with a given variable name is optional when the only variable with that name is a global variable.

#include <iostream>

void read();
int scope=10;

int main()
{
    int scope=11;
    //this two function call has the same effect.
    read();
    ::read();

    std::cout<<scope<<std::endl;//11
    std::cout<<::scope<<std::endl;//10
}

void read()
{
    std::cout<<"I'm in grobal:read"<<std::endl;
}

Overload Function

 C++ enables several functions of the same name to be defined, as long as they have different signatures.A signature is a combination of a function’s name and its parameter types (in order). The compiler uses only the parameter lists to distinguish between overloaded functions. Creating overloaded functions with identical parameter lists and different return types is a compilation error.Member functions of a class can be overloaded, but only by other member functions of that class.

The compiler encodes each function identifier with the number and types of its parameters (sometimes referred to as name mangling or name decoration) to enable type-safe linkage.Function-name mangling is compiler specific.Below show the mangled function names produced in assembly language by GNU C++. Each mangled name (other than main) begins with two underscores (__) followed by the letter Z, a number and the function name. The number that follows Z specifies how many characters are in the function’s name.The function name is then followed by an encoding of its parameter list The return types of the functions are not specified in the mangled names. 

int square(int x){return x*x;}

double square(double y){return y*y;}

void nothing1( int a, float b, char c, int &d ){}

int nothing2( char a, int b, float &c, double &d ){return 0;}

int main()
{

}

//g++ -S overload.cpp -o overload.s
//_Z6squarei
//_Z6squared
//_Z8nothing1ifcRi
//_Z8nothing2ciRfRd

Function Template

You write a single function template definition. Given the argument types provided in calls to this function, C++ automatically generates separate function template specializations to handle each type of call appropriately.

#include <iostream>

//The formal type parameters are placeholders for fundamental types or user-defined
template<typename T>
T findMax(T a,T b,T c)
{
    T max;
    max = a;
    if(b>max)
        max=b;
    if(c>max)
        max=c;
    return max;
}

int main()
{
    int a=1,b=2,c=3;
    double d=1.1,e=1.2,f=1.3;
    char cha='a',chb='b',chc='c';

    std::cout<<"Max in 1,2,3 is:"<<findMax(a,b,c)<<std::endl;
    std::cout<<"Max in 1.1,1.2,1.3 is:"<<findMax(d,e,f)<<std::endl;
    std::cout<<"Max in a,b,c is:"<<findMax(cha,chb,chc)<<std::endl;
}

//Max in 1,2,3 is:3
//Max in 1.1,1.2,1.3 is:1.3
//Max in a,b,c is:c

 

---

 Class 

Class Scope

Variables declared in a member function have local scope and are known only to that function. If a member function defines a variable with the same name as a variable with class scope, the class-scope variable is hidden by the block-scope variable in the local scope.Such a hidden variable can be accessed by preceding the variable name with the class name followed by the scope resolution operator (::). Hidden global variables can be accessed with the scope resolution operators.

//scope.cpp
#include <iostream>
using namespace std;

int variable = 100;

void boo();
class Foo
{
public:
    static const int variable = 300;
};


int main()
{
    boo();
}

void boo()
{
    int variable = 200;
    cout<<"grobal variable:"<<::variable<<endl;
    cout<<"function variable:"<<variable<<endl;
    cout<<"class variable:"<<Foo::variable<<endl;

}

 Accessing Class Member

 A class’s data members and member functions belong to that class’s scope. Nonmember functions are defined at global namespace scope.Outside a class’s scope, public class members are referenced through one of the handles on an object—an object name, a reference to an object or a pointer to an object.

// Demonstrating the class member access operators . and ->
#include <iostream>
using std::cout;
using std::endl;

// class Count definition
class Count 
{
public: // public data is dangerous
   // sets the value of private data member x
   void setX( int value )
   {
      x = value;
   } // end function setX

   // prints the value of private data member x
   void print() 
   { 
      cout << x << endl; 
   } // end function print

private:
   int x;  
}; // end class Count

int main()
{
   Count counter; // create counter object 
   Count *counterPtr = &counter; // create pointer to counter
   Count &counterRef = counter; // create reference to counter

   cout << "Set x to 1 and print using the object's name: ";
   counter.setX( 1 ); // set data member x to 1
   counter.print(); // call member function print

   cout << "Set x to 2 and print using a reference to an object: ";
   counterRef.setX( 2 ); // set data member x to 2
   counterRef.print(); // call member function print

   cout << "Set x to 3 and print using a pointer to an object: ";
   counterPtr->setX( 3 ); // set data member x to 3
   counterPtr->print(); // call member function print
   return 0;  
} // end main

Access Functions and Utility function

A utility function is not part of a class’s public interface; rather, it’s a private member function that supports the operation of the class’s other member functions. Utility functions are not intended to be used by clients of a class

#ifndef SALESP_H
#define SALESP_H

class SalesPerson 
{
public:
   SalesPerson(); // constructor
   void getSalesFromUser(); // input sales from keyboard
   void setSales( int, double ); // set sales for a specific month
   void printAnnualSales(); // summarize and print sales
private:
   double totalAnnualSales(); // prototype for utility function
   double sales[ 12 ]; // 12 monthly sales figures
}; // end class SalesPerson

#endif

// Member functions for class SalesPerson.
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
using std::fixed;

#include <iomanip>
using std::setprecision;

#include "SalesPerson.h" // include SalesPerson class definition

// initialize elements of array sales to 0.0
SalesPerson::SalesPerson()
{
   for ( int i = 0; i < 12; i++ )
      sales[ i ] = 0.0;
} // end SalesPerson constructor

// get 12 sales figures from the user at the keyboard
void SalesPerson::getSalesFromUser()
{
   double salesFigure; 

   for ( int i = 1; i <= 12; i++ ) 
   {
      cout << "Enter sales amount for month " << i << ": ";
      cin >> salesFigure;
      setSales( i, salesFigure );
   } // end for
} // end function getSalesFromUser

// set one of the 12 monthly sales figures; function subtracts
// one from month value for proper subscript in sales array
void SalesPerson::setSales( int month, double amount )
{
   // test for valid month and amount values
   if ( month >= 1 && month <= 12 && amount > 0 )
      sales[ month - 1 ] = amount; // adjust for subscripts 0-11
   else // invalid month or amount value
      cout << "Invalid month or sales figure" << endl;   
} // end function setSales

// print total annual sales (with the help of utility function)
void SalesPerson::printAnnualSales()
{
   cout << setprecision( 2 ) << fixed 
      << "\nThe total annual sales are: $" 
      << totalAnnualSales() << endl; // call utility function
} // end function printAnnualSales

// private utility function to total annual sales
double SalesPerson::totalAnnualSales()
{
   double total = 0.0; // initialize total

   for ( int i = 0; i < 12; i++ ) // summarize sales results
      total += sales[ i ]; // add month i sales to total

   return total;                   
} // end function totalAnnualSales

#include "SalesPerson.h"  

int main()
{
   SalesPerson s; // create SalesPerson object s
   
   s.getSalesFromUser(); // note simple sequential code;
   s.printAnnualSales(); // no control statements in main
   return 0;
} // end main

Constructor

2013-03-23 00:52:31

In C++, the code that runs when an object is declared is called the constructor.Constructor is part of the public section of the class.If the constructor were not public, then no instances of the object could be created.

Const field initialization

If you declare a field of your class as const, then that field must be initialized in the initialization list:

The default arguments to the constructor ensure that, even if no values are provided in a constructor call, the constructor still initializes the data members. A constructor that defaults all its arguments is also a default constructor—that is, a constructor that can be invoked with no arguments. There can be at most one default constructor per class.

//ConstructorWithDefaultArgument.h
#ifndef __ARGUMENT_H__
#define __ARGUMENT_H__

class Time{
public:
    Time(int =12,int =0,int =0);
    void setTime(int h,int m,int s);
    int getTime();
private:
    int hour;
    int minute;
    int second;
    
};
#endif

//----------------------------------------------------------------------
//ConstructorWithDefaultArgument.cpp
#include <iostream>
#include "ConstructorWithDefaultArgument.h"
using namespace std;

Time::Time(int h,int m,int s)
{
    setTime(h,m,s);
}

void Time::setTime(int h,int m,int s)
{
    hour = h;
    minute = m;
    second = s;
}

int Time::getTime()
{
    int t;
    t = hour *10000+minute*100+second;
    cout<<"Here is the time: "<<t<<endl; 
}

#include "ConstructorWithDefaultArgument.h"

//----------------------------------------------------------------------
//main.cpp
int main()
{
    Time myTime1;
    Time myTime2(13);
    Time myTime3(13,14);
    Time myTime4(13,14,15);

    myTime1.getTime();
    myTime2.getTime();
    myTime3.getTime();
    myTime4.getTime();
}

Having the Time constructor call setTime  enables us to limit the changes to code that validates the hour, minute or second to the corresponding set function. This reduces the likelihood of errors when altering the class’s implementation.

If a member function of a class already provides all or part of the functionality required by a constructor (or other member function) of the class, call that member function from the constructor (or other member function). This simplifies the maintenance of the code and reduces the likelihood of an error if the implementation of the code is modified. As a general rule: Avoid repeating code.

When Constructor and Destructor are called

The order in which these function calls occur depends on the order in which execution enters and leaves the scopes where the objects are instantiated.Generally, destructor calls are made in the reverse order of the corresponding constructor calls.

 A class’s destructor is called implicitly when an object is no longer needs. So what does it actually mean for an object to be "no longer needed"? It means one of three things:
1)  When you delete a pointer to an object
2)  When the object goes out of scope
3)  When the object belongs to a class whose destructor is being called

This occurs, for example, as an automatic object is destroyed when program execution leaves the scope in which that object was instantiated. The destructor itself does not actually release the object’s.memory—it performs termination housekeeping before the object’s memory is reclaimed, so the memory may be reused to hold new objects.If you do not explicitly provide a destructor, the compiler creates an “empty” destructor.It’s a syntax error to attempt to pass arguments to a destructor, to specify a return type for a destructor (even void cannot be specified), to return values from a destructor or to overload a destructor.

//Destructor.h
 #ifndef __DESTRUCTOR_H__
 #define __DESTRUCTOR_H__
 
 class Destructor
 {
 public:
     Destructor(int n);
     ~Destructor();
 private:
     int number;
 };
 
 
 #endif
 
 //--------------------------------------------------------------------------
 //Destructor.cpp
 #include <iostream>
 #include "Destructor.h"
 
 using namespace std;
 
 Destructor::Destructor(int n)
 {
     number = n;
     cout<<"Constructor: object "<<number<<endl;
 }
 
 Destructor::~Destructor()
 {
     cout<<"Destructor: object "<<number<<endl;
 }
 
 
 //--------------------------------------------------------------------------
 //main.cpp
 #include "Destructor.h"
 
 Destructor myDestructor1(1);
 void create();
 
 int main()
 {
     static Destructor myDestructor2(2);
     Destructor myDestructor3(3);
     create();
     Destructor myDestructor4(4);
 }
 
 void create()
 {
     Destructor myDestructor5(5);
     static Destructor myDestructor6(6);
     Destructor myDestructor7(7);
 }

Default Memberwise Assignment

2013-03-23  11:40:52

 The assignment operator (=) can be used to assign an object to another object of the same type. By default, such assignment is performed by memberwise assignment—each data member of the object on the right of the assignment operator is assigned individually to the same data member in the object on the left of the assignment operator.

Caution: Memberwise assignment can cause serious problems when used with a class whose data members contain pointers to dynamically allocated memory.

Objects may be passed as function arguments and may be returned from functions. Such passing and returning is performed using pass-by-value by default—a copy of the object is passed or returned. In such cases, C++ creates a new object and uses a copy constructor to copy the original object’s values into the new object. For each class, the compiler provides a default copy constructor that copies each member of the original object nto the corresponding member of the new object.

Passing an object by value is good from a security standpoint, because the called function has no access to the original object in the caller, but pass-by-value can degrade performance when making a copy of a large object. An object can be passed by reference by passing either a pointer or a reference to the object. Pass-by-reference offers good performance but is weaker from a security standpoint, because the called function is given access to the original object. Pass-by-const-reference is a safe, good-performing alternative (this can be implemented with a const reference parameter or with a pointer-to-const-data parameter).

//DefaultMemberwise.h
#ifndef __DEFAULT_MEMBERWISE_H__
#define __DEFAULT_MEMBERWISE_H__

class Memberwise
{
public:
    Memberwise(int y=2013,int m=3,int d=23);
    void getDate();
private:
    int year;
    int month;
    int date;
};

#endif

//--------------------------------------------------------------------------
//DefaultMemberwise.cpp
#include "DefaultMemberwise.h"
#include <iostream>
using namespace std;

Memberwise::Memberwise(int y,int m,int d):year(y),month(m),date(d)
{
    
}

void Memberwise::getDate()
{
    cout<<"date:"<<    year*10000+month*100+date<<endl;
}

//-------------------------------------------------------------------------
//main.cpp
#include "DefaultMemberwise.h"

int main()
{
    Memberwise myMemberwise1(2012,12,12);
    Memberwise myMemberwise2;

    myMemberwise1.getDate();
    myMemberwise2.getDate();

    myMemberwise2=myMemberwise1;
    myMemberwise2.getDate();
}

 

Const Object and Const Member Function

 2013-03-23 20:25:27

 You may use keyword const to specify that an object is not modifiable and that any attempt to modify the object should result in a compilation error.Declaring variables and objects const when appropriate can improve performance—compilers can perform optimizations on constants that cannot be performed on variables.

C++ disallows member function calls for const objects unless the member functions themselves are also declared const. Invoking a non-const member function on a const object is a compilation error.

A member function is specified as const both in its prototype by inserting the keyword const after the function’s parameter list and, in the case of the function definition, before the left brace that begins the function body.The fact that a member function does not modify an object is not sufficient to indicate that the function is a constant function—the function must explicitly be declared const.A const member function can't modify a data member or call a none-const member function.But a const member function can be overloaded with a non-const version. The compiler chooses which overloaded member function to use based on the object on which the function is invoked. If the object is const, the compiler uses the const version. If the object is not const, the compiler uses the non-const version.

Attempting to declare a constructor or destructor const is a compilation error.A constructor must be a non-const member function , but it can still be used to initialize a const object.Invoking a nonconst member function from the constructor call as part of the initialization of a const object is allowed. The “constness” of a const object is enforced from the time the constructor completes initialization of the object until that object’s destructor is called.

All data members can be initialized using member initializer syntax, but const data members and data members that are references must be initialized using member initializers. We’ll also see that member objects must be initialized this way as well.

Declare as const all of a class’s member functions that do not modify the object in which they operate.Declaring such member functions const does offer a benefit,. If the member function is inadvertently written to modify the object, the compiler will issue an error message.

//const.h
#ifndef __CONST_H__
#define __CONST_H__

class Book
{
public:
    Book(int e,int m,int p);
    void setData(int e);
    //Declare as const all if it do not modify the object 
    void getDate() const;
    void displayDate();

private:
    int english;
    //warning ,should better not unless it is static member
    const int math =96;
    const int physics;
    
};

#endif

//--------------------------------------------------------------------------
//const.cpp
#include <iostream>
#include "Const.h"
using namespace std;

Book::Book(int e,int m,int p):physics(p)
{
//Invoking a nonconst member function from the constructor
    setData(e);
}

void Book::setData(int e)
{
    english =e;
}

void Book::getDate()const
{
    cout<<"english: "<<english<<endl;
    cout<<"math:    "<<math<<endl;
    cout<<"physics  "<<physics<<endl;

}

void Book::displayDate()
{
    cout<<"english: "<<english<<endl;
    cout<<"math:    "<<math<<endl;
    cout<<"physics  "<<physics<<endl;
}

//-------------------------------------------------------------------------
//main.cpp
#include "Const.h"

int main()
{
    const Book myBook1(93,94,95);
    Book myBook2(83,84,85);

    myBook2.getDate();//ok
    myBook2.displayDate();//ok
    myBook1.getDate();//ok
                //error, displayData() is not const member function
    //myBook1.displayDate();
    
}

 

Composition

 2013-03-24 10:04:23

 Member objects are constructed in the order in which they’re declared in the class definition (not in the order they’re listed in the constructor’s member initializer list) and before their enclosing class objects are constructed.To confirm in the  program output we see that objects are constructed from the inside out and destroyed in the reverse order, from the outside in.That is the Employee destructor runs first  then the member objects are destructed in the reverse order from which they were constructed. (i.e., the Date member objects are destroyed after the Employee object that contains them).

The compiler provides each class with a default copy constructor that copies each data member of the constructor’s argument object into the corresponding member of the object being initialized.When each of the Employee’s Date member object’s is initialized in the Employee constructor’s member initializer list , the default copy constructor for class Date is called. Since this constructor is defined implicitly by the compiler, it does not contain any output statements to demonstrate when it’s called.So we can't see any output from two objects' constructor of Date.If a member object is not initialized through a member initializer, the member object’s default constructor will be called implicitly.So if we change the Employee's constructor to the form of none initialize the object members explicity,we will see the output form the Date constructor.A compilation error occurs if a member object is not initialized with a member initializer and the member object’s class does not provide a default constructor.

//-------------------------------------------------------------------------
//composition_date.h
#ifndef __COM_DATE_H__
#define __COM_DATE_H__
using namespace std;

class Date
{
public:
    Date(int year=2012,int month=12,int day=12);
    ~Date();
    //void setData(int year,int month,int day);
    //void getData() const;
private:
    int year;
    int month;
    int day;
};



#endif


//-------------------------------------------------------------------------
//composition_date.cpp
#include <iostream>
#include "composition_date.h"
using namespace std;

Date::Date(int year, int month ,int day)
            :year(year),month(month),day(day)
{
    cout<<"Date Constructor: "<<year<<"/"<<month<<"/"<<day<<endl;    
}

Date::~Date()
{

    cout<<"Date Destructor: "<<year<<"/"<<month<<"/"<<day<<endl;
}

//-------------------------------------------------------------------------
//composition_employee.h
#include "composition_date.h"
#include <iostream>
using namespace std;

class Employee
{
public:
    Employee(string,string,const Date &);
    ~Employee();
private:
    string firstName;
    string lastName;
    Date birthDate;
    Date employDate;
};


//-------------------------------------------------------------------------
//composition_employee.cpp
#include "composition_date.h"
#include "composition_employee.h"
#include <iostream>
using namespace std;

Employee::Employee(string firstN,string lastN,const Date & birthD)
            :firstName(firstN),lastName(lastN),birthDate(birthD)
{
    cout<<"employee contructor"<<endl;
}

Employee::~Employee()
{
    cout<<"employee destructor"<<endl;
}


//-------------------------------------------------------------------------
//main.cpp
#include <iostream>
#include "composition_date.h"
#include "composition_employee.h"
using namespace std;

int main()
{
    Date bD(2012,1,1);
    Date eD(2013,3,3);
    cout<<endl;
    
                //There are actually five constructor call.
    Employee myEmployee("benson","huang",bD);
    
    cout<<endl;
    cout<<"main exit..."<<endl;
}

Friend

 2013-03-25 13:12:34

A friend function of a class is defined outside that class’s scope, yet has the right to access the non-public (and public)members of the class.Standalone functions, entire classes or member functions of other classes may be declared to be friends of another class.

To declare a function as a friend of a class,precede the function prototype in the class definition with keyword friend.To declare all member functions of class ClassTwo as friends of class ClassOne,place a declaration of the form in the definition of class ClassOne.

friend class ClassTwo;                     

Member access notions of private, protected and public are not relevant to friend declarations,so friend declarations can be placed anywhere in a class definition. Place notice that it is better to all friendship declarations first inside the classdefinition’s body and do not precede them with any access specifier.

Friendship is granted, not taken. Also, the friendship relation is neither symmetric nor transitive;i.e., if class A is a friend of class B,and class B is a friend of class C, you cannot infer that class B is a friend of class A , that class C is a friend of class B , or that class A is a friend of class C .

#include <iostream>
using namespace std;

class Year
{
friend void setYear(Year &,int);
public:
    int getYear(){return year;}
private:
    int year;
};

void setYear(Year & oYear,int y);

int main()
{
    Year oYear;
    int thisYear = 2013;
    cout<<"Before setting,this year is: "<<oYear.getYear()<<endl;
    setYear(oYear,thisYear);
    cout<<"After setting,this year is: "<<oYear.getYear()<<endl;
}

This

Every objecthas ac-cess to itsown address through apointercalled this (a C++keyword). The this pointer is not part of the object itself—i.e.,the memory occupiedbythe this pointerisnot re-flectedinthe result of a sizeof operation on theobject.The typeofthe this pointer depends on thetype of the object and whether the member function in which this is used is declared const.For example,in a nonconstant member function of class Employee,the this pointer hastype Employee *const (a constant pointer to a nonconstant Employee object). In aconstant member function of theclass Employee,the this pointerhas the data type const Employee *const (a constant pointer to a constant Employee object).Another use of the this pointer is to enable cascaded member-function calls—that is, invoking multiple functions in the same statement.

//this.h
#ifndef __THIS_H__
#define __THIS_H__

class Time
{
public:
    Time(int=0,int=0,int=0);
    Time & setTime(int,int,int);
    void printTime()const;
private:
    int hour;
    int minute;
    int second;
};

#endif


//--------------------------------------------------------------------------
//this.cp
#include <iostream>
#include <iomanip>
#include <stdexcept>
#include "this.h"
using namespace std;

Time::Time(int hour,int minute,int second)
{
    setTime(hour,minute,second);
}

Time& Time::setTime(int h,int m,int s)
{
    if(h>=0 && h <=24)
        hour =h;
    else
        throw invalid_argument("hour:1~24");

    if(m>=0 && m<=59)
        minute = m;
    else
        throw invalid_argument("minute:1~59");

    if(s>=0 && s<=59)
        second = s;
    else
        throw invalid_argument("second:1~59");

    return *this;
}

void Time::printTime()const
{
    cout<<"Time: "<<setfill('0')<<setw(2)<<( (hour ==0 || hour==12)?12:hour%12 )<<":"
        <<setfill('0')<<setw(2)<<minute<<":"<<setfill('0')<<setw(2)<<second
        <<" "<<(hour<12 ? "am":"pm")<<endl;
}

//--------------------------------------------------------------------------
//main.cpp

#include "this.h"

int main()
{
    Time time;
    time.printTime();
    time.setTime(14,7,28).printTime();
}

 

---

C File Processing

Data Hierarchy

The smallest data item in a computer can assume the value 0 or the value 1. Such a data item is called a bit.Just as characters are composed of bits, fields are composed of characters. A field is a group of characters that conveys meaning.A record (i.e., a struct in C) is composed of several fields.A group of related files is sometimes called a database. A collection of programs designed to create and manage databases is called a database management system (DBMS).

To facilitate the retrieval of specific records from a file, at least one field in each record is chosen as a record key. A record key identifies a record as belonging to a particular person or entity.There are many ways of organizing records in a file. The most popular type of organization is called a sequential file, in which records are typically stored in order by the
record key field. 

Files and Streams

C views each file simply as a sequential stream of bytes . Each file ends either with an end-of-file marker or at a specific byte number recorded in a system-maintained,administrative data structure. When a file is opened, a stream is associated with the file.Three files and their associated streams are automatically opened when program execution begins—the standard input, the standard output and the standard error. Streams provide communication channels between files and programs.Opening a file returns a pointer to a FILE structure (defined in <stdio.h>) that contains information used to process the file. This structure includes a file descriptor, i.e., an index into an operating system array called the open file table. Each array element contains a file control block (FCB) that the operating system uses to administer a particular file. The standard input, standard output and standard error are manipulated using file pointers stdin, stdout and stderr.

//equivalent
fgetc(stdin);
getchar();

//equivalent
fputc('a',stdout);
putchar('a');

 

---

New & Delete 

The object or array is created in the free store (also called the heap)—a region of memory assigned to each program for storing dynamically allocated objects.

New 

The new operator allocates storage of the proper size for an object of type Time, calls the default constructor to initialize the object and returns a pointer to the type specified to the right of the new operator (i.e., a Time *). If new is unable to find sufficient space in memory for the object, it indicates that an error occurred by throwing an exception.The keyword new is used to initialize pointers with memory form free store.

int * pInt = new int;
Time * poTime = new Time();

The code that uses pInt must eventually return this memory back to the free store,an operation called freeing the memory. To return the memory back to free store,you use the delete keyword.The delete operation frees up the memory allcoted through new.This statement first calls the destructor for the object to which timePtr points, then deallocates the memory associated with the object, returning the memory to the free store.

delete pInt;
pInt=NULL;

delete poTime;
poTime=NULL;

You can dynamically allocate an array of memory using new and assign the memory to a pointer.The size of an array created at compile time must be specified using a constant integral expression; however, a dynamically allocated array’s size can be specified using any non-negative integral expression that can be evaluated at execution time. Also, when allocating an array of objects dynamically, you cannot pass arguments to each object’s constructor—each object is initialized by its default constructor. For fundamental types, the elements are initialized to 0 or the equivalent of 0 (e.g., chars are initialized to the null character, '\0').

int * paInt = new int[8];

If the pointer points to an array of objects, the statement first calls the destructor for every object in the array, then deallocates the memory. If the preceding statement did not include the
square brackets ([]) and gradesArray pointed to an array of objects, the result is undefined.
Some compilers call the destructor only for the first object in the array. Using delete on a null pointer (i.e., a pointer with the value 0) has no effect.

int gradeArray[] = new int[10];
delete [] gradeArray;

Delete

Now you can use paInt just as if it pointed to an array.Unlink array,though,you need to free the memory pointed to by paInt,whereas ,you never want to free a pointer pointing to a statically declared array.The brackets tell the compiler that the pointer points to an array of values rather than a signal value.

delete[] paInt;

'delete' and 'delete[]' are different if the type of the array is 'class T',but the same with primitive type.

#include <iostream>
using namespace std;

class T
{
public:
    T()
    {
        count++;
        cout<<"constructor: "<<count<<endl;

    }
    ~T()
    {
        cout<<"destructor: "<<count<<endl;
        --count;
    }
private:
    static int count;
};

int T::count=0;


int main()
{
    const int size = 3;
    T * mInstance=new T[size];
    //only free the memory occupied by mInstance[0]
    delete mInstance;

    T * mInstance_1=new T[size];
    //free the memory occupied by mInstance_1[0] mInstance_1[1] mInstance_1[2]
    delete[] mInstance_1;
}

Use Case 

#include <iostream>
#include <cstring>
#include <stdio.h>

using namespace std;

int * growArray(int * pointer,int *pSize);

int main()
{
    int size=3;
    int * pointer=new int[size];
    memset(pointer,0,size*sizeof(int));
    int nextElement=0;
    int val;

    cout<<"Please enter integer number:\n"<<endl;
    cin>>val;

    while(0!=val)
    {
        //if the array's size is not enough,enlarge the array.
        if(size==nextElement)
        {
            pointer=growArray(pointer,&size);
        }

        pointer[nextElement]=val;
        ++nextElement;
        cout<<"Please enter integer number(or 0 to exit):\n"<<endl;
        cin>>val;
    }//End of while.

    //print out the int array after the user enter '0'
    cout<<"the int array you enter is:"<<endl;
    for(int i=0;0!=pointer[i];++i)
    {
        cout<<pointer[i]<<"  "<<endl;
    }//End of print int array.

}//End of function main.

int * growArray(int * pointer,int *pSize)
{
    int size=*pSize;
    int newSize=size*2;
    *pSize *=2;
    int * newPointer=new int[newSize];
    memset(newPointer,0,newSize*sizeof(int));

    for(int i=0;i<size;++i)
    {
        newPointer[i]=pointer[i];
    }
    //'delete pointer' is also ok,because pointer points to an array of primitive type.
    delete[] pointer;
    return newPointer;
}

 

---

Inheritance & Polymorphism

Base classes and derived classes

With multiple inheritance, a derived class inherits from two or more (possibly unrelated) base classes.Each arrow in the hierarchy (Fig. 12.2) represents an is-a relationship.CommunityMember is the direct base class of Employee, Student and Alumnus. In addition, CommunityMember is an indirect base class of all the other classes in the diagram.

With all forms of inheritance, private members of a base class are not accessible directly from that class’s derived classes, but these private base-class members are still inherited.With public inheritance, all other base-class members retain their original member access when they become members of the derived class(e.g., public members of the base class become public members of the derived class, and,as we’ll soon see, protected members of the base class become protected members of the

derived class).

class Apple:public Shape
{
  
};

Relationship between SubClass and SuperClass

Derived-class member functions can refer to public and protected members of the base class simply by using the member names.When a derived-class member function redefines a base-class member function, the base-class member can still be accessed from the derived class by preceding the base-class member name with the base-class name and the scope resolution operator (::).

#include <iostream>

using namespace std;

class Book
{
public:
    void cover();
};

void Book::cover()
{
    cout<<"SuperClass:cover()"<<endl;
}

class Physical:public Book
{
public:
    void cover();
};

void Physical::cover()
{
    //base class member function can still be accessed.
    Book::cover();
    cout<<"SubClass:cover()"<<endl;
}

int main()
{
    Physical myPhysical;
    //output:"SuperClass:cover()"
    //       "SubClass:cover()"
    myPhysical.cover();
}

C++ requires that a derived-class constructor call its base-class constructor to initialize the base-class data members that are inherited into the derived class.If Subclass’s constructor did not invoke Super Class's constructor explicitly, C++ would attempt to invoke SuperClass’s default constructor implicitly—but if the SuperClass does not have such a constructor, so the compiler would issue an error.

Constructor and Destructor in Derived Classes

When a program creates a derived-class object, the derived-class constructor immediately calls the base-class constructor, the base-class constructor’s body executes, then the derived class’s member initializers execute and finally the derived-class constructor’s body executes. This process cascades up the hierarchy if it contains more than two levels.

When a derived-class object’s destructor is called, the destructor performs its task, then invokes the destructor of the next base class up the hierarchy. This process repeats until the destructor of the final base class at the top of the hierarchy is called. Then the object is removed from memory.

#include <iostream>
#include <string>

using namespace std;

class Book
{
public:
    //self-define constructor,and there is no default constructor in the class.
    Book(const string & strRef);
    ~Book();
};

Book::Book(const string & strRef)
{
    cout<<"constructor Book:"<<strRef<<endl;
}

Book::~Book()
{
    cout<<"Destructor Book"<<endl;
}

class Physical:public Book
{
public:
    Physical(const string & strRef);
    ~Physical();
};

//call the superclass's constructor in the initialization list.
//if we do not call that constructor,we will get a compile which fail
//to call Book::Book();
Physical::Physical(const string & strRef):Book(strRef)
{
    cout<<"Constructor Physical"<<endl;
}

Physical::~Physical()
{
    cout<<"Destructor Physical"<<endl;
}

int main()
{
    Physical * myPhysical = new Physical("benson");
    delete myPhysical;
    while(true);
}
//output::
//constructor Book:benson
//Constructor Physical
//Destructor Physical
//Destructor Book

Public,Protected and Private Inheritance

When deriving a class from a base class, the base class may be inherited through public,protected or private inheritance.Figure 12.16 summarizes for each type of inheritance the accessibility of base-class members in a derived class.

 Invoking Base-Class functions from Derived-Class

Invoking a function via the base-class pointer invokes the base-class functionality in the derived-class object—i.e., the type of the handle determines which function is called.

#include <iostream>

 using namespace std;

 class Book
 {
 public:
     void cover();
     virtual void cost();
 };

 void Book::cover()
 {
     cout<<"SuperClass:cover()"<<endl;
 }

void Book::cost()
{
    cout<<"cost() in Book"<<endl;
}

 class Physical:public Book
 {
 public:
     void cover();
     virtual void cost();
     void page();
 };

 void Physical::cover()
 {
     cout<<"SubClass:cover()"<<endl;
 }

void Physical::cost()
{
    cout<<"cost() in Physical"<<endl;
}

 void Physical::page()
 {
     cout<<"SubClass:page()"<<endl;
 }

 int main()
 {
    //Base-Class pointer point to Derived-Class.
    Book * poBook=new Physical();
    poBook->cover();//SuperClass:cover()

    //if a base-class pointer is aimed at a derived-class object, and an attempt is
    //made to access a derived-class-only member function, a compilation error will occur.
    poBook->page();//error

    //if we explicitly cast the base-class pointer to
    //a derived-class pointer—this is known as downcasting,we can
    //access to derived-class-only members.
    ((Physical *)poBook)->page();

    //Derived-Class pointer point to Base-Class will get an compiler error.
    Physical * poPhysical = new Book();//error
}

Virtual Functions

From an implementation perspective, overriding a function is no different than redefining one. An overridden function in a derived class has the same signature and return type (i.e., prototype) as the function it overrides in its base class. If we do not declare the base-class function as virtual, we can redefine that function. By contrast, if we declare the base-class function as virtual, we can override that
function to enable polymorphic behavior.

If a program invokes a virtual function through a base-class pointer to a derivedclass object or a base-class reference to a derived-class object, the program will choose the correct derived-class draw function dynamically (i.e., at execution time) based on the object type—not the pointer or reference
type. Choosing the appropriate function to call at execution time (rather than at compile time) is known as dynamic binding or late binding.

int main()
{
    //Base-Class Book's cost() function is override by the Derived-Class function
    poBook->cost();//output:'cost() ins Physical'

    //dynamic binding with virtual functions occurs only off
    //pointer as well as reference handles.
    Physical myPhysical;
    Book & bookRef=myPhysical;
    bookRef.cost();//output:'cost() ins Physical'
}

Abstract Classes and Pure Virtual Functions

There are cases in which it’s useful to define classes from which you never intend to instantiate any objects. Such classes are called abstract classes. Because these classes normally are used as base classes in inheritance hierarchies, we refer to them as abstract base classes.These classes cannot be used to instantiate objects,classes that can be used to instantiate objects are called concrete classes.

A class is made abstract by declaring one or more of its virtual functions to be “pure.” A pure virtual function is specified by placing “= 0” in its declaration, Pure virtual functions do not provide implementations. Every concrete derived class must override all base-class pure virtual functions with concrete implementations of those functions.

virtual void draw() const = 0; // pure virtual function

The difference between a virtual function and a pure virtual function is that a virtual function has an implementation and gives the derived class the option of overriding the function; by contrast, a pure virtual function does not provide an implementation and requires the derived class to override the function for that derived class to be concrete; otherwise the derived class remains abstract

Simple Polymorphism 

#include <iostream>
#include <vector>

using namespace std;

class Shape
{
public:
    virtual void draw()=0;
};

class Apple:public Shape
{
public:
    virtual void draw()
    {
        cout<<"Draw Apple."<<endl;
    }
};

class Pear:public Shape
{
    virtual void draw()
    {
        cout<<"Draw Pear."<<endl;
    }
};

int main()
{
    vector<Shape *> SomeShape;
    SomeShape.push_back(new Apple());
    SomeShape.push_back(new Pear());

    for(vector<Shape *>::iterator itr=SomeShape.begin(),end=SomeShape.end();itr!=end;++itr)
    {
        (*itr)->draw();
    }
}

 Polymorphism,Virtual Functions and Dynamic Binding "under the hood"

1、The UML class diagram shows the inheritance hierarchy for our polymorphic employee payroll application.

 

2、Source Code

// Employee.h
// Employee abstract base class.
#ifndef EMPLOYEE_H
#define EMPLOYEE_H

#include <string> // C++ standard string class
using std::string;

class Employee 
{
public:
   Employee( const string &, const string &, const string & );

   void setFirstName( const string & ); // set first name
   string getFirstName() const; // return first name

   void setLastName( const string & ); // set last name
   string getLastName() const; // return last name

   void setSocialSecurityNumber( const string & ); // set SSN
   string getSocialSecurityNumber() const; // return SSN

   // pure virtual function makes Employee abstract base class
   virtual double earnings() const = 0; // pure virtual
   virtual void print() const; // virtual
private:
   string firstName;
   string lastName;
   string socialSecurityNumber;
}; // end class Employee

#endif // EMPLOYEE_H

//Employee.cpp
// Abstract-base-class Employee member-function definitions.
// Note: No definitions are given for pure virtual functions.
#include <iostream>
using std::cout;

#include "Employee.h" // Employee class definition

// constructor
Employee::Employee( const string &first, const string &last,
   const string &ssn )
   : firstName( first ), lastName( last ), socialSecurityNumber( ssn )
{
   // empty body 
} // end Employee constructor

// set first name
void Employee::setFirstName( const string &first ) 
{ 
   firstName = first;  
} // end function setFirstName

// return first name
string Employee::getFirstName() const 
{ 
   return firstName;  
} // end function getFirstName

// set last name
void Employee::setLastName( const string &last )
{
   lastName = last;   
} // end function setLastName

// return last name
string Employee::getLastName() const
{
   return lastName;   
} // end function getLastName

// set social security number
void Employee::setSocialSecurityNumber( const string &ssn )
{
   socialSecurityNumber = ssn; // should validate
} // end function setSocialSecurityNumber

// return social security number
string Employee::getSocialSecurityNumber() const
{
   return socialSecurityNumber;   
} // end function getSocialSecurityNumber

// print Employee's information (virtual, but not pure virtual)
void Employee::print() const
{ 
   cout << getFirstName() << ' ' << getLastName() 
      << "\nsocial security number: " << getSocialSecurityNumber(); 
} // end function print

//SalariedEmployee.h
// SalariedEmployee class derived from Employee.
#ifndef SALARIED_H
#define SALARIED_H

#include "Employee.h" // Employee class definition

class SalariedEmployee : public Employee 
{
public:
   SalariedEmployee( const string &, const string &, 
      const string &, double = 0.0 );

   void setWeeklySalary( double ); // set weekly salary
   double getWeeklySalary() const; // return weekly salary

   // keyword virtual signals intent to override
   virtual double earnings() const; // calculate earnings
   virtual void print() const; // print SalariedEmployee object
private:
   double weeklySalary; // salary per week
}; // end class SalariedEmployee

#endif // SALARIED_H

//SalariedEmployee.cpp
// SalariedEmployee class member-function definitions.
#include <iostream>
using std::cout;

#include "SalariedEmployee.h" // SalariedEmployee class definition

// constructor 
SalariedEmployee::SalariedEmployee( const string &first, 
   const string &last, const string &ssn, double salary )
   : Employee( first, last, ssn )
{ 
   setWeeklySalary( salary ); 
} // end SalariedEmployee constructor

// set salary
void SalariedEmployee::setWeeklySalary( double salary )
{ 
   weeklySalary = ( salary < 0.0 ) ? 0.0 : salary; 
} // end function setWeeklySalary

// return salary
double SalariedEmployee::getWeeklySalary() const
{
   return weeklySalary;
} // end function getWeeklySalary

// calculate earnings; 
// override pure virtual function earnings in Employee
double SalariedEmployee::earnings() const 
{ 
   return getWeeklySalary(); 
} // end function earnings

// print SalariedEmployee's information 
void SalariedEmployee::print() const
{
   cout << "salaried employee: ";
   Employee::print(); // reuse abstract base-class print function
   cout << "\nweekly salary: " << getWeeklySalary();
} // end function print

//CommissionEmployee.h
// CommissionEmployee class derived from Employee.
#ifndef COMMISSION_H
#define COMMISSION_H

#include "Employee.h" // Employee class definition

class CommissionEmployee : public Employee 
{
public:
   CommissionEmployee( const string &, const string &,
      const string &, double = 0.0, double = 0.0 );

   void setCommissionRate( double ); // set commission rate
   double getCommissionRate() const; // return commission rate

   void setGrossSales( double ); // set gross sales amount
   double getGrossSales() const; // return gross sales amount

   // keyword virtual signals intent to override
   virtual double earnings() const; // calculate earnings
   virtual void print() const; // print CommissionEmployee object
private:
   double grossSales; // gross weekly sales
   double commissionRate; // commission percentage
}; // end class CommissionEmployee

#endif // COMMISSION_H

// CommissionEmployee.cpp
// CommissionEmployee class member-function definitions.
#include <iostream>
using std::cout;

#include "CommissionEmployee.h" // CommissionEmployee class definition

// constructor 
CommissionEmployee::CommissionEmployee( const string &first, 
   const string &last, const string &ssn, double sales, double rate )
   : Employee( first, last, ssn )  
{
   setGrossSales( sales );
   setCommissionRate( rate );
} // end CommissionEmployee constructor

// set commission rate
void CommissionEmployee::setCommissionRate( double rate )
{ 
    commissionRate = ( ( rate > 0.0 && rate < 1.0 ) ? rate : 0.0 );
} // end function setCommissionRate

// return commission rate
double CommissionEmployee::getCommissionRate() const
{
    return commissionRate;
} // end function getCommissionRate

// set gross sales amount
void CommissionEmployee::setGrossSales( double sales ) 
{ 
   grossSales = ( ( sales < 0.0 ) ? 0.0 : sales ); 
} // end function setGrossSales

// return gross sales amount
double CommissionEmployee::getGrossSales() const
{
    return grossSales;
} // end function getGrossSales

// calculate earnings;
// override pure virtual function earnings in Employee
double CommissionEmployee::earnings() const
{ 
   return getCommissionRate() * getGrossSales(); 
} // end function earnings

// print CommissionEmployee's information 
void CommissionEmployee::print() const
{
   cout << "commission employee: ";
   Employee::print(); // code reuse
   cout << "\ngross sales: " << getGrossSales() 
      << "; commission rate: " << getCommissionRate();
} // end function print

// BasePlusCommissionEmployee.h
// BasePlusCommissionEmployee class derived from Employee.
#ifndef BASEPLUS_H
#define BASEPLUS_H

#include "CommissionEmployee.h" // CommissionEmployee class definition

class BasePlusCommissionEmployee : public CommissionEmployee 
{
public:
   BasePlusCommissionEmployee( const string &, const string &,
      const string &, double = 0.0, double = 0.0, double = 0.0 );

   void setBaseSalary( double ); // set base salary
   double getBaseSalary() const; // return base salary

   // keyword virtual signals intent to override
   virtual double earnings() const; // calculate earnings
   virtual void print() const; // print BasePlusCommissionEmployee object
private:
   double baseSalary; // base salary per week
}; // end class BasePlusCommissionEmployee

#endif // BASEPLUS_H

//  BasePlusCommissionEmployee.cpp
// BasePlusCommissionEmployee member-function definitions.
#include <iostream>
using std::cout;

// BasePlusCommissionEmployee class definition
#include "BasePlusCommissionEmployee.h"

// constructor 
BasePlusCommissionEmployee::BasePlusCommissionEmployee( 
   const string &first, const string &last, const string &ssn, 
   double sales, double rate, double salary )
   : CommissionEmployee( first, last, ssn, sales, rate )  
{
   setBaseSalary( salary ); // validate and store base salary
} // end BasePlusCommissionEmployee constructor

// set base salary
void BasePlusCommissionEmployee::setBaseSalary( double salary )
{ 
   baseSalary = ( ( salary < 0.0 ) ? 0.0 : salary ); 
} // end function setBaseSalary

// return base salary
double BasePlusCommissionEmployee::getBaseSalary() const
{ 
    return baseSalary; 
} // end function getBaseSalary

// calculate earnings;
// override pure virtual function earnings in Employee
double BasePlusCommissionEmployee::earnings() const
{ 
    return getBaseSalary() + CommissionEmployee::earnings(); 
} // end function earnings

// print BasePlusCommissionEmployee's information 
void BasePlusCommissionEmployee::print() const
{
   cout << "base-salaried ";
   CommissionEmployee::print(); // code reuse
   cout << "; base salary: " << getBaseSalary();
} // end function print

//main.cpp
// Processing Employee derived-class objects individually 
// and polymorphically using dynamic binding.
#include <iostream>
using std::cout;
using std::endl;
using std::fixed;

#include <iomanip>
using std::setprecision;
  
#include <vector>
using std::vector;

// include definitions of classes in Employee hierarchy
#include "Employee.h"
#include "SalariedEmployee.h" 
#include "CommissionEmployee.h"  
#include "BasePlusCommissionEmployee.h" 

void virtualViaPointer( const Employee * const ); // prototype
void virtualViaReference( const Employee & ); // prototype

int main()
{
   // set floating-point output formatting
   cout << fixed << setprecision( 2 );

   // create derived-class objects
   SalariedEmployee salariedEmployee( 
      "John", "Smith", "111-11-1111", 800 );
   CommissionEmployee commissionEmployee( 
      "Sue", "Jones", "333-33-3333", 10000, .06 );
   BasePlusCommissionEmployee basePlusCommissionEmployee( 
      "Bob", "Lewis", "444-44-4444", 5000, .04, 300 );
   
   cout << "Employees processed individually using static binding:\n\n";

   // output each Employee's information and earnings using static binding
   salariedEmployee.print();
   cout << "\nearned $" << salariedEmployee.earnings() << "\n\n";
   hourlyEmployee.print(); 
   cout << "\nearned $" << hourlyEmployee.earnings() << "\n\n";
   commissionEmployee.print();
   cout << "\nearned $" << commissionEmployee.earnings() << "\n\n";
   basePlusCommissionEmployee.print();
   cout << "\nearned $" << basePlusCommissionEmployee.earnings() 
      << "\n\n";

   // create vector of four base-class pointers
   vector < Employee * > employees( 3 );

   // initialize vector with Employees
   employees[ 0 ] = &salariedEmployee;
   employees[ 1 ] = &commissionEmployee;
   employees[ 2 ] = &basePlusCommissionEmployee;

   cout << "Employees processed polymorphically via dynamic binding:\n\n";

   // call virtualViaPointer to print each Employee's information
   // and earnings using dynamic binding
   cout << "Virtual function calls made off base-class pointers:\n\n";

   for ( size_t i = 0; i < employees.size(); i++ )
      virtualViaPointer( employees[ i ] );

   // call virtualViaReference to print each Employee's information 
   // and earnings using dynamic binding
   cout << "Virtual function calls made off base-class references:\n\n";

   for ( size_t i = 0; i < employees.size(); i++ )    
      virtualViaReference( *employees[ i ] ); // note dereferencing

   return 0;
} // end main

// call Employee virtual functions print and earnings off a 
// base-class pointer using dynamic binding
void virtualViaPointer( const Employee * const baseClassPtr )
{
   baseClassPtr->print();
   cout << "\nearned $" << baseClassPtr->earnings() << "\n\n";
} // end function virtualViaPointer

// call Employee virtual functions print and earnings off a 
// base-class reference using dynamic binding
void virtualViaReference( const Employee &baseClassRef )
{
   baseClassRef.print();
   cout << "\nearned $" << baseClassRef.earnings() << "\n\n";
} // end function virtualViaReference

 3、Output:

 

4、Under the Hood

When C++ compiles a class that has one or more virtual functions, it builds a virtual function table (vtable) for that class. An executing program uses the vtable to select the proper function implementation each time a virtual function of that class is called.Whenever an object of a class with one or more virtual functions is instantiated, the compiler attaches to the object a pointer to the vtable for that class.The third level of pointers simply contains the handles to the objects that receive the virtual function calls

When the compiler compiles this statement, it determines that the call is indeed being made via a base-class pointer and that print is a virtual function.The compiler determines that print is the second entry in each of the vtables. To locate this entry, the compiler notes that it will need to skip the first entry. Thus, the compiler compiles an offset or displacement into the table of machine-language object-code pointers to find the code that will execute the virtual function call. The size in bytes of the offset depends on the number of bytes used to represent a pointer on an individual platform.

The compiler generates code that performs the following operations

1). Select the ith entry of employees (in this case, the address of object commissionEmployee), and pass it as an argument to function virtualViaPointer. This sets parameter baseClassPtr to point to commissionEmployee.

2). Dereference that pointer to get to the commissionEmployee object—which, as you recall, begins with a pointer to the CommissionEmployee vtable.

3). Dereference commissionEmployee’s vtable pointer to get to the CommissionEmployee vtable

4). Skip the offset of four bytes to select the print function pointer.

5). Dereference the print function pointer to form the “name” of the actual function to execute, and use the function call operator () to execute the appropriate print function, which in this case prints the employee’s type, name, social security number, gross sales and commission rate.

Fig. 13.18’s data structures may appear to be complex, but this complexity is managed by the compiler and hidden from you, making polymorphic programming straightforward.The pointer dereferencing operations and memory accesses that occur on every virtual function call require some additional execution time. The vtables and the vtable pointers added to the objects require some additional memory.

 

---

Operator Overloading

#include <stdexcept>
#include <iostream>
#include <string>

using namespace std;

int main()
{
    string str1("better ");
    string str2("late ");
    string str3="than ";
    string str4;
    string str5;

    //copy constructor
    //This results in a call to class string's copy constructor.
    string str6(str5);

    //support logic operators:== != > < >= <=
    if(str1==str2)
    {
        cout<<"str1==str2"<<endl;
    }
    else if(str1>str2)
    {
        cout<<"str1>str2"<<endl;
    }
    else if(str1<str2)
    {
        cout<<"str1<str2"<<endl;
    }
    //support assignment operator：=
    str4=str1;
    //self-assignment.
    str6=str6;
    //support concatenate operator：+.
    str5 +=str1+str2+str3+"never";
    //subscript operator：[]
    //class string's [] operator does not perform any bounds checking.
    str5[0]='B';
    str5[7]='L';
    str5[12]='T';
    str5[17]='N';
    cout<<str5<<endl;

    //function "substr"
    cout<<str5.substr(0,20)<<endl;
    cout<<str5.substr(0)<<endl;
    //function "empty"
    str5.empty()?cout<<"empty"<<endl:cout<<"not empty"<<endl;
    //function "at"
    //function 'at' throws an exception if its argument is an invalid subcript.
    try
    {
        str5.at(40)='A';
    }
    catch(out_of_range &e)
    {
        cout<<e.what()<<endl;
    }

}

Fundamentals Of Operator Overloadding

Operator overloading is not automatic—you must write operator-overloading functions to perform the desired operations. An operator is overloaded by writing a nonstatic member function definition or non-member function definition.When operators are overloaded as member functions, they must be non-static,because they must be called on an object of that class or operate on that object.To use an operator on an object of a class, the operator must be overloaded for that class—with three exceptions:"=" 、"&" 、"," these three operators can be used with every object without overloadding priviously.

As you prepare to overload operator with your own classes, there are several rules and restrictions you should keep in mind:

• The precedence of an operator cannot be changed by overloading. However, parentheses can be used to force the order of 　　　　   evaluation of overloaded operators in an expression.
• The associativity of an operator cannot be changed by overloading—if an operator normally associates from left to right, then 　　   so do all of its overloaded versions.
• You cannot change the “arity” of an operator (that is, the number of operands an operator takes)—overloaded nary perators 　　remain unary operators; overloaded binary operators remain binary operators. Operators &, *, + and - all have both unary and binary versions; these unary and binary versions can be separately overloaded.
• You cannot create new operators; only existing operators can be overloaded.
• The meaning of how an operator works on values of fundamental types cannot be changed by operator overloading. For example, you cannot make the + operator ubtract two ints. Operator overloading works only with objects of user-defined
types or with a mixture of an object of a user-defined type and an object of a fundamental type.
• Related operators, like + and +=, must be overloaded separately.
• When overloading (), [], -> or any of the assignment operators, the operator overloading function must be declared as a class member. For all other overloadable operators, the operator overloading functions can be member functions or
non-member functions.

Overload Binary Operator

1、overloadded as non-static member function

A binary operator can be overloaded as a non-static member function with one parameter or as a non-member function with two parameters . A non-member operator function is often declared as friend of a class for performance reasons.

They’re non-member functions because the object of class PhoneNumber must be the operator’s right operand

#include <iostream>
#include <iomanip>
#include <string>
using namespace std;

class PhoneNumber
{
    //'operator<<' and 'operator>>' are declared friend if they meed to access non-public
    //class members directly for the performance reasons or because the class does not offer
    //appropriate get functions.
    friend ostream & operator<<(ostream & output,const PhoneNumber & phone);
    friend istream & operator>>(istream & input,PhoneNumber & phone);

private:
    string areaCode;
    string exchange;
    string line;
};

//'operator<<' and 'operator>>' are declared as non-member functions because
//the object of class PhoneNumber is wanted to be the operator's right operand.
ostream & operator<<(ostream & output,const PhoneNumber & phone);
istream & operator>>(istream & input,PhoneNumber & phone);

ostream & operator<<(ostream & output,const PhoneNumber & phone)
{
    output<<"("<<phone.areaCode<<")"<<" "<<phone.exchange<<"-"<<phone.line<<endl;
    return output;
}

istream & operator>>(istream &input,PhoneNumber & phone)
{
    //parentheses space dash are skipped by input's member function 'ignore()'.
    input.ignore();
    //stream manipulator 'setw()' limits the number of characters read into each stream.
    input>>setw(3)>>phone.areaCode;
    input.ignore(2);
    input>>setw(3)>>phone.exchange;
    input.ignore(1);
    input>>setw(4)>>phone.line;

    return input;
}

int main()
{
    cout<<"Please enter a phone number in the form:\'(020) 123-4567\'"<<endl;
    PhoneNumber oPhone;
    cin>>oPhone;
    cout<<"output phone number:"<<oPhone;
}

Overloading Unary Operators

A unary operator for a class can be overloaded as a non-static member function with no arguments or as a non-member function with one argument that must be an object (or a reference to an object) of the class. Member functions that implement overloaded operators must be non-static so that they can access the non-static data in each object of the class.

#ifndef DATE_H_INCLUDED
#define DATE_H_INCLUDED
#include <iostream>

using namespace std;

class Date
{
    friend ostream& operator<<(ostream & output,const Date & date);
public:
    //Constructors and Destructor
    Date(int=1,int=1,int=2000);
    ~Date();

    //Interface
    bool setDate(int m,int d,int y);
    Date& operator++();//prefix increment operator
    //Note that this function return Date object by value
    Date operator++(int);//postfix increment operator
    Date& operator+=(int);

private:
    //Utility functions
    static bool isLeapYear(int y);
    bool isEndOfMonth(int dd);
    void increment();

    //Private data.
    int _year;
    int _month;
    int _day;
    static const string _year2String[13];
    static const int _monthDay[13];
};

#endif // DATE_H_INCLUDED
//-------------------------------------------------------------------------------------------
#include <iostream>
#include <string>
#include <stdexcept>
#include "Date.h"

using namespace std;

ostream& operator<<(ostream & output,const Date & date)
{
    cout<<date._year2String[date._month]<<" "<<date._day<<" ,"<<date._year;
    return output;
}

Date::Date(int m,int d,int y)
{
    setDate(m,d,y);
}

Date::~Date()
{

}

bool Date::setDate(int m,int d,int y)
{
    if(0<m&&13>m)
        _month=m;
    else
    {
        throw invalid_argument("month out of range.");
    }

    if( (d>0&&d<=_monthDay[m]) || (isLeapYear(y)&&m==2&&d>0&&d<=29) )
    {
        _day=d;
    }
    else
    {
        throw invalid_argument("Day out of range.");
    }

    if(y>0)
    {
        _year=y;
    }
    else
    {
        throw invalid_argument("invalid year.");
    }

    return true;
}

Date& Date::operator++()
{
    increment();
    return *this;
}

//Note that the dummy integer parameter does not has a parameter name.
Date Date::operator++(int)
{
    //must occure before increment() called.
    //hold current state of object.
    Date temp=*this;
    increment();
    //return a temporary object the contains the original value of the object
    //before the increment occured.
    return temp;
}

Date& Date::operator+=(int nDays)
{
    for(int i=0;i<nDays;++i)
    {
        increment();
    }

    return *this;
}

bool Date::isLeapYear(int y)
{
    if((y%100!=0)&&(y%4==0) || (y%400==0) )
        return true;
    else
        return false;
}

bool Date::isEndOfMonth(int dd)
{
    if(_month==2&&isLeapYear(_year))
        return dd==29;
    else
        return dd==_monthDay[_month];
}

void Date::increment()
{
    if(!isEndOfMonth(_day))
    {
        ++_day;
    }
    else
    {
        if(_month<12)
        {
            ++_month;
            _day=1;
        }
        else
        {
            ++_year;
            _month=1;
            _day=1;
        }
    }
}

const int Date::_monthDay[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
const string Date::_year2String[13]={"","January","February","March","April","May","June",
            "July","August","September","October","November","December"};

//------------------------------------------------------------------------------------------------------
#include <iostream>
#include "Date.h"

using namespace std;

int main()
{
    Date d1(1,1,1999);
    Date d2(10,31,2013);

    d1.setDate(1,1,2000);
    cout<<"  d1:"<<d1<<endl;
    cout<<"++d1:"<<++d1<<endl;
    cout<<"  d1:"<<d1<<endl;

    cout<<"\n\nd1  :"<<d1<<endl;
    //When the complier sees the postincrementing expression d1++,it generates the
    //member-function call d1.operator++(0);
    cout<<"d1++:"<<d1++<<endl;
    cout<<"d1  :"<<d1<<endl;

    d1++.setDate(1,1,1990);
    cout<<d1<<endl;

    Date * poDate=new Date;
    cout<<"\n\n"<<*poDate;
    Date * poDate_2=new Date();
    cout<<"\n\n"<<*poDate_2;


}

Array Class

 In this example, we create a powerful Array class that performs range checking to ensure that subscripts remain within the bounds of the Array. The class allows one array object to be assigned to another with the assignment operator. Array objects know their size, so the size does not need to be passed separately to functions that receive Array parameters. Entire Arrays can be input or output with the stream extraction and stream insertion operators, respectively. You can compare Arrays with the equality operators == and !=.

//main.cpp
//--------------------------------------------------------------------------------
#include <iostream>
#include "Array.h"

using namespace std;

void outputArray(const Array &);

int main()
{
    Array arrayOne(12);
    //test constructor with default argument.
    Array arrayTwo;
    //test overloadded operator <<
    cout<<arrayOne<<endl;
    cout<<arrayTwo<<endl;
    //test getSize() function
    cout<<"arrayTwo's size is:"<<arrayTwo.getSize()<<endl;

    //test >>
    Array arrayThird(5);
    Array arrayFourth(11);
    cout<<"Enter 16 integers:"<<endl;
    cin>>arrayThird>>arrayFourth;
    cout<<arrayThird<<arrayFourth<<endl;

    //test copy constructor
    Array arrayFifth(arrayOne);
    cout<<arrayFifth<<endl;

    //test overloadded operator []
    Array array(6);
    for(int i=0;i<array.getSize();++i)
    {
        array[i]=i;
    }
    cout<<array<<endl;
    //test overloadded operator =
    Array array_1(8);
    array_1=array;
    array=array;
    cout<<array_1<<endl;

    //test overloadded operator == !=
    Array array_2(7);
    array_2==array?cout<<"array_2==array"<<endl:cout<<"array_2!=array"<<endl;
    array_2!=array?cout<<"array_2!=array"<<endl:cout<<"array_2==array"<<endl;
    array_1==array?cout<<"array_1==array"<<endl:cout<<"array_1!=array"<<endl;

    const Array array_const(6);
    for(int i=0;i<array_const.getSize();++i)
    {
        cout<<"array_const["<<i<<"]="<<array_const[i]<<endl;
    }

    Array myArray(7);
    outputArray(myArray);
    outputArray(3);
}


//Array.h
//--------------------------------------------------------------------------------

#ifndef __ARRAY_H__
#define __ARRAY_H__

#include <iostream>
using namespace std;

class Array
{
    friend ostream& operator<<(ostream&,const Array&);
    friend istream& operator>>(istream&,Array&);
public:
    Array(int=10);
    Array(const Array&);//copy constructor.
    ~Array();

    int getSize() const;

    //overload operators
    const Array& operator=(const Array&);
    bool operator==(const Array&) const;
    bool operator!=(const Array&) const;
    //subscript for non-const objcet returns lvalue.
    int& operator[](int);
    //subscript for const objcet returns rvalue.
    int operator[](int) const;
private:
    int _size;
    int * _pInt;
};

#endif // __ARRAY_H__

//Array.cpp
//--------------------------------------------------------------------------------
#include <iostream>
#include <iomanip>
#include <stdexcept>
#include <string.h>
#include "Array.h"

using namespace std;

ostream& operator<<(ostream& output,const Array& array)
{
    output<<"Array Int["<<array.getSize()<<"]:\n";
    for(int i=0;i<array.getSize();++i)
    {
        output<<array._pInt[i]<<"\t";
        if((i+1)%8==0 )
        {
            output<<endl;
        }
    }
    //output two array continously without this statment will get and runtime error???
    output<<endl;

    return output;
}

istream& operator>>(istream& input,Array& array)
{
    for(int i=0;i<array.getSize();++i)
    {
        input>>array._pInt[i];
    }

    return input;
}

Array::Array(int arraySize)
{
    //parameter validation must needded.
    if(arraySize<0)
    {
        throw invalid_argument("array size must be positive.\n");
    }
    else
    {
        _size=arraySize;
        _pInt=new int[_size];
        //need to initialize the new created array.
        //why this function cannot set every element of the array to 0?????
        //but the for-loop done.
        //memset(_pInt,'\0',_size);
        for(int i=0;i<_size;++i)
        {
            _pInt[i]=0;
        }
    }
}

//copy constructor.
//memberwise assignment is dangerous for classed with pointer members.
//so we need to wirte a copy constructor.
Array::Array(const Array& array):_size(array._size)
{
    _pInt=new int[_size];
    for(int i=0;i<_size;++i)
    {
        _pInt[i]=array._pInt[i];
    }
}

Array::~Array()
{
    //release pointer-base array space
    delete [] _pInt;
}

int Array::getSize() const
{
    return _size;
}

//const return avoids (a1=a2)=a3
//avoids self-assigment,note that the size of the array may be different.
const Array& Array::operator=(const Array& array)
{
    if(&array!=this)
    {
        if(_size!=array._size)
        {
            delete [] _pInt;
            _size=array._size;
        }

        _pInt=new int[_size];
        for(int i=0;i<_size;++i)
        {
            _pInt[i]=array._pInt[i];
        }
    }

    return *this;//enables x=y=z for example.
}

//return true if all the private data of class array is the same.
bool Array::operator==(const Array& array) const
{
    if(_size!=array._size)
        return false;

    for(int i=0;i<_size;++i)
    {
        if(_pInt[i]!=array._pInt[i])
            return false;
    }

    return true;
}//end of function operator==()

bool Array::operator!=(const Array& array) const
{
    return !(*this==array);//invoke Array::operator==
}

//subscript for non-const objcet returns lvalue.
int& Array::operator[](int n)
{
    if(n<0||n>_size-1)
        throw invalid_argument("subscript out of range.");
    return _pInt[n];//reference return;
}

//subscript for const objcet returns rvalue.
int Array::operator[](int n) const
{
    if(n<0||n>=_size)
        throw invalid_argument("subscript out of range.");

    return _pInt[n];//copy return;
}

Converting between Types

The compiler knows how to perform certain conversions among fundamental types. You can use cast operators to force conversions among fundamental types.But what about user-defined types? The compiler cannot know in advance how to convert among user-defined types, and between user-defined types and fundamental types, so you must specify how to do this. Such conversions can be performed with conversion
constructors—single-argument constructors that turn objects of other types (including fundamental types) into objects of a particular class.A conversion operator (also called a cast operator) can be used to convert an object of one class into an object of another class or into an object of a fundamental type. Such a
conversion operator must be a non-static member function.

//declares an overloaded cast operator function for converting an object of user-defined type
//A into a temporary char * object.
//An overloaded cast operator function does not specify a return type—the return type is the type 
//to which the object is being converted.
// If s is a class object, when the compiler sees the expression static_cast< char * >( s ), the compiler
//generates the call s.operator char *()
A::operator char *() const;
//declare overloaded cast operator functions that can convert an object of user-defined type A
//into an object of user-defined type OtherClass.
A::operator OtherClass() const;

One of the nice features of cast operators and conversion constructors is that, when necessary, the compiler can call these functions implicitly to create temporary objects. For example, if an object s of a user-defined String class appears in a program at a location where an ordinary char * is expected, such as  cout << s;the compiler can call the overloaded cast-operator function operator char * to convert the object into a char * and use the resulting char * in the expression. With this cast operator provided for a String class, the stream insertion operator does not have to be overloaded to output a String using cout.

 explicit Constructors

Any single-argument constructor—except a copy constructor—can be used by the compiler to perform an implicit conversion. The constructor’s argument is converted to an object of the class in which theconstructor is defined. The conversion is automatic and you need not use a cast operator. In some situations, implicit conversions are undesirable or errorprone.

#include <iostream>
#include "Array.h"

using namespace std;

void outputArray(const Array &);

int main()
{
    Array myArray(7);
    outputArray(myArray);
    outputArray(3);
}

void outputArray(const Array &array_1)
{
    cout<<array_1<<endl;
}

Line 12 calls function outputArray with the int value 3 as an argument. However, this program does not contain a function called outputArray that takes an int argument.So, the compiler determines whether class Array provides a conversion constructor that can convert an int into an Array. Since the Array constructor receives one int argument, the compiler assumes that the constructor is a conversion constructor that can be used to convert the argument 3 into a temporary Array object containing three elements. Then, the
compiler passes the temporary Array object to function outputArray to output the Array’s contents. Thus, even though we do not explicitly provide an outputArray function that receives an int argument, the compiler is able to compile line 12.

C++ provides the keyword explicit to suppress implicit conversions via conversion constructors when such conversions should not be allowed. A constructor that’s declared explicit cannot be used in an implicit conversion.So,what we only have to do is adding  a additional keyword explicit  into the constructor Array(int=10); defined in  in Array.h.

explicit Array( int = 10 ); // default constructor

    Array myArray(7);
    outputArray(myArray);
    //this time ,this statement gets an error.
    outputArray(3);
    //demonstrates how the explicit constructor can be used to create a temporary
    // Array of 3 elements and pass it to function outputArray.
    outputArray(Array(3));

 

---

Templates

Introduction

Function templates and class templates enable you to specify, with a single code segment, an entire range of related (overloaded) functions—called function-template specializations—or an entire range of related classes—called class-template specializations.This technique is called generic programming.Note the distinction between templates and template specializations: Function templates and class templates are like stencils out of which we trace shapes; function-template specializations and class-template specializations are like the separate tracings that all have the same shape, but could, for example, be drawn in different colors.templates are often defined in headers, which are then #included in the appropriate client source-code files. For class templates, this means that the member functions are also defined in the header.

Function Templates

Initially, you write a single function-template definition. Based on the argument types provided explicitly or inferred from calls to this function, the compiler generates separate source-code functions (i.e., function-template specializations) to handle each function call appropriately.

// Using template functions.
#include <iostream>
using std::cout;
using std::endl;

// function template printArray definition
template< typename T >
void printArray( const T *array, int count )
{
   for ( int i = 0; i < count; i++ )
      cout << array[ i ] << " ";

   cout << endl;
} // end function template printArray

int main()
{
   const int aCount = 5; // size of array a
   const int bCount = 7; // size of array b
   const int cCount = 6; // size of array c

   int a[ aCount ] = { 1, 2, 3, 4, 5 };
   double b[ bCount ] = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7 };
   char c[ cCount ] = "HELLO"; // 6th position for null

   cout << "Array a contains:" << endl;

   // call integer function-template specialization
   printArray( a, aCount );  

   cout << "Array b contains:" << endl;

   // call double function-template specialization
   printArray( b, bCount );  

   cout << "Array c contains:" << endl;

   // call character function-template specialization
   printArray( c, cCount );  
   return 0;
} // end main

When the compiler detects a printArray function invocation in the client program (e.g., lines 29 and 34), the compiler uses its overload resolution capabilities to find a definition of function printArray that best matches the function call. In this case, the only printArray function with the appropriate number of parameters is the printArray function template (lines 7–14).Consider the function call at line 29. The compiler compares the type of printArray’s first argument (int * at line 29) to the printArray function template’s first parameter (const T * const at line 8) and deduces that replacing the type parameter T with int would make the argument consistent with the parameter. Then, the compiler substitutes int for T throughout the template definition and compiles a printArray specialization that can display an array of int values.In this example, the template mechanism saves you from having to write two separate overloaded functions with prototypes

void printArray( const int * const, int );
void printArray( const double * const, int );
void printArray( const char * const, int );

Although templates offer software-reusability benefits, remember that multiple functiontemplate specializations and class-template specializations are instantiated in a program (at compile time), despite the fact that the templates are written only once. These copies can consume considerable memory. This is not normally an issue, though, because the code generated by the template is the same size as the code you’d have written to produce the separate overloaded functions.

 Function Templates Can Be Overloadded

A function template may be overloaded in several ways. We can provide other function templates that specify the same function name but different function parameters.A function template also can be overloaded by providing nontemplate functions with the same function name but different function arguments.

The compiler performs a matching process to determine what function to call when a function is invoked. First, the compiler tries to find and use a precise match in which the function names and argument types are consistent with those of the function call. If this fails, the compiler determines whether a function template is available that can be used to generate a function-template specialization with a precise match of function name and argument types that are consistent with those of the function call. If such a template is
found, the compiler generates and uses the appropriate function-template specialization. If not, the compiler generates an error message. Also, if there are multiple matches for the function call, the compiler attempts to determine the best match. If there is more than one best match, the call is ambiguous and the compiler generates an error message.

Class Templates

 

 

 

---

Conventions

1、I have also put underscores before each private element of the class to make it easier to tell what is private, but it is not a requirement of C++. It looks a bit ugly at first, but I find it makes a big difference when you're reading the code! If you follow this convention, just make sure that you do not use a capital letter after the underscore; this prefix may cause conflicts with some compilers. As long as you stick with a lowercase letter after the underscore when declaring private fields or methods, you’ll be fine.

In my own code, I always start with a public section, followed by a private section. This emphasizes that the public section is meant for users of the class (other programmers) because it is the first thing that a user of the class will see.

class ChessBoard
{ 
public:
    ChessPiece getPiece (int x, int y); 
    PlayerColor getMove (); 
    void makeMove (int from_x, int from_y, int to_x, int to_y); 
private:
    ChessPiece _board[ 8 ][ 8 ]; 
    PlayerColor _whose_move; 
};

 2、After deleting a pointer, it is a good idea to reset it to point to NULL again:

delete pInt;
pInt =NULL;

 3、Typical Class Design

Typical Class Design
 //SysTest.h
 //-----------------------------------------------------------------
 #ifndef __SYS_TEST_H__
 #define __SYS_TEST_H__
 
 #define LOG(msg) std::cout<<__FILE__<<"-"<<__LINE__<<":"<<msg<<std::endl;
 
 class SysTest
 {
 public:
     SysTest();
     ~SysTest();
     static SysTest * instance();
     bool connectIPC();
 private:
     static SysTest * poInstance;
 };
 
 #endif
 
 //SysTest.cpp
 //------------------------------------------------------------------------
 #include "SysTest.h"
 
 SysTest * SysTest::poInstance=0;
 
 SysTest * SysTest::instance()
 {
     if(0==poInstance)
     {
         poInstance = new SysTest();
     }
 
     return poInstance;
 }
 
 bool SysTest::connectIPC()
 {
 
 }
 
 
 //main.cpp
 //-----------------------------------------------------------------
 
 #include "SysTest.h"
 
 int main()
 {
     if(!SysTest::instance()->connectIPC())
         {
         LOG("connect IPC failed");
         return -1;
     }
     
 }