第一章

例 1-1　hello.cpp

​x
1
#include <iostream>
2
using namespace std;
3
int main()
4
{
5
    cout << "hello C++" << endl;
6
        return 0;
7
}
8

例1-1所示的C++程序，文件扩展名是“.cpp”。

第1行代码作用是包含标准输入/输出头文件iostream。

第2行代码作用是引用标准命名空间std。

第5行代码在屏幕输出“hello C++”。

cout是预定义的输出流对象，用于输出数据；endl表示换行。

例1-2　format.cpp

xxxxxxxxxx
14
1
#include<iostream>
2
#include<iomanip>
3
using namespace std;
4
int main()
5
{
6
    cout<<setw(10)<<3.1415<<endl;
7
    cout<<setw(10)<<setfill('0')<<3.1415<<endl;
8
    cout<<setw(10)<<setfill('0')
9
                     <<setiosflags(ios::left)<<3.1415<<endl;
10
    cout<<setw(10)<<setfill('-')
11
                     <<setiosflags(ios::right)<<3.1415<<endl;
12
    return 0;
13
}
14

在例1-2中，第6行代码输出了指定域宽的数据，

第7行代码输出了填充了字符的数据，

第8～11行代码输出的是设置了左对齐和右对齐格式的数据。

例1-3　defaultPara.cpp

xxxxxxxxxx
14
1
#include <iostream>
2
using namespace std; 
3
void add(int x,int y=1,int z=2) 
4
{
5
    cout<<x+y+z<<endl;
6
}
7
int main()
8
{
9
    add(1);         //只传递1给形参x，y、z使用默认形参值
10
    add(1,2);       //传递1给x，2给y,z使用默认形参值
11
    add(1,2,3);     //传递三个参数，不使用默认形参值
12
    return 0;
13
}
14

在例1-3中，第3～6行代码定义了函数add()，该函数指定了参数y、z的默认值。

第9～11行代码在main()中调用了三次add()函数。

• 第一次调用add()函数时，只传入一个参数1，形参y、z使用默认参数；
• 第二次调用时，传入参数1、2，形参z使用默认参数；
• 第三次调用时，传入参数1、2、3，不使用默认参数。

例1-4　overloadFunc.cpp

xxxxxxxxxx
21
1
#include <iostream>
2
using namespace std;
3
void add(int x, int y)
4
{
5
    cout << "int: " << x + y << endl;
6
}
7
void add(double x)
8
{
9
    cout << "double: " << 10 + x << endl;
10
}
11
double add(double x, double y)
12
{
13
    return x + y;
14
}
15
int main()
16
{
17
    add(10.2);          //一个double类型参数
18
    add(1, 3);          //两个int类型参数
19
    return 0;
20
}
21

在例1-4中，第3～14行代码定义了三个重载函数add()。

第17行代码调用add()函数，传入一个double类型的实参10.2。

第18行代码调用add()函数，传入两个int类型的实参1和3。

例1-5　reference.cpp

xxxxxxxxxx
12
1
#include<iostream>
2
using namespace std;
3
int main()
4
{
5
    int a=10;
6
    int &ra=a;
7
    cout<<"变量a的地址"<<hex<<&a<<endl;
8
    cout<<"引用ra的地址:"<<hex<<&ra<<endl;
9
    cout<<"引用ra的值:"<<dec<<ra<<endl;
10
    return 0;
11
}
12

在例1-5中，第5行代码定义了整型变量a并初始化为10。

第6行代码定义了指向变量a的引用ra。

第7～9行代码分别输出变量a的地址、引用ra的地址、引用ra的值。

例1-6　quote.cpp

xxxxxxxxxx
18
1
#include <iostream>
2
using namespace std;
3
void exchange(int& x, int& y)
4
{
5
    int temp = x;
6
    x = y;
7
    y = temp;
8
}
9
int main()
10
{
11
    int a, b;
12
    cout << "please input two nums: " << endl;
13
    cin >> a >> b;
14
    exchange(a, b);
15
    cout << " exchange: " << a << " "<< b << endl;
16
    return 0;
17
}
18

在例1-6中，第3～8行代码定义了一个函数exchange()，用于交换两个int类型变量的值。exchange()函数有两个int类型的引用作为参数。

第13～15行代码通过cin从键盘输入两个整型数据给变量a、b，调用exchange()函数交换变量a、b的值，并输出交换结果。

例1-7　allocMeorry.cpp

xxxxxxxxxx
20
1
#include<iostream>
2
using namespace std;
3
int main()
4
{
5
    int *pi = new int(10);      //new 一个int对象，初始值为10
6
    cout<<"*pi="<<*pi<<endl;
7
    *pi = 20;                   //通过指针改变内存中的值
8
    cout<<"*pi = "<<*pi<<endl;
9
    //创建一个大小为10char类型的数组
10
    char *pc = new char[10];
11
    for (int i = 0;i < 10;i++)
12
        pc[i] = i + 65;         //向数组中存入元素
13
    for (int i = 0;i < 10;i++)
14
        cout<<pc[i]<<" ";
15
    cout<<endl;
16
    delete pi;                      //释放int对象
17
    delete []pc;                    //释放char数组对象
18
    return 0;
19
}
20

在例1-7中，第5行代码使用new创建了一个int对象，初始值为10。

第6行代码通过指针pi输出内存中的数据，输出结果为10。

第7～8行代码通过指针pi修改内存中的数据为20，并输出，输出结果为20。

第10～12行代码使用new创建一个大小为10的char类型数组，并通过for循环为数组赋值。

第13～14行代码通过for循环输出数组中的元素，

第16～17行代码使用delete运算符释放int对象和char类型数组对象。

例1-8　mallocStr.h

xxxxxxxxxx
4
1
#include <stdio.h>
2
#include <stdlib.h>
3
char* func(int,char*);
4

例1-9　mallocStr.c

xxxxxxxxxx
9
1
#define _CRT_SECURE_NO_WARNINGS
2
#include"mallocStr.h"
3
char* func(int size,char *str)
4
{
5
    char *p =malloc(size);
6
    strcpy(p,str);
7
    return p;
8
}
9

例1-8和例1-9的mallocStr.h文件和mallocStr.c文件所示代码是C语言程序。其中，mallocStr.c文件中定义了func()函数，在函数内部调用malloc()函数申请一块内存空间存储一个字符串。func()函数第一个参数指定申请内存的大小，第二个参数是存入内存空间的字符串。

例1-10　main.cpp

xxxxxxxxxx
19
1
#include<iostream>
2
 using namespace std;
3
#ifdef __cplusplus
4
extern "C"
5
{
6
#endif 
7
    #include"mallocStr.h"
8
#ifdef __cplusplus
9
}
10
#endif 
11
int main()
12
{
13
     char str[]="C++";
14
    char *p=func(sizeof(str)+1,str);
15
    cout<<p<<endl;
16
    free (p);
17
    return 0;
18
}
19

在例1-10所示的main.cpp中，程序调用了func()函数，则需要使用extern "C" 声明m allocStr.h文件内容以C语言的方式编译。

第二章

例2-1　Student.cpp

下面通过案例演示类的定义、对象的创建及对象的成员访问，如例2-1所示。

xxxxxxxxxx
29
1
#include <iostream>
2
using namespace std;
3
class Student                           //定义学生类Student
4
{
5
public:                                 //公有类型
6
    void study();                       //声明表示学习的成员函数
7
    void exam();                        //声明表示考试的成员函数           
8
    string _name;                       //声明表示姓名的成员变量
9
    int _age;                           //声明表示年龄的成员变量
10
};
11
void Student::study()                   //类外实现studey()成员函数
12
{
13
    cout << "学习C++" << endl;
14
}
15
void Student::exam()                    //类外实现exam()成员函数
16
{
17
    cout << "C++考试成绩100分" << endl;
18
}
19
int main()
20
{
21
    Student stu;                        //创建Student类对象
22
    stu._name = "张三";                   //设置对象姓名
23
    stu._age = -20;                     //设置对象年龄
24
    cout << stu._name << stu._age << "岁" << endl;
25
    stu.study();                        //调用study()成员函数
26
    stu.exam();                         //调用exam()成员函数
27
    return 0;
28
}
29

在 例2-1 中，第3～10行代码定义了学生类 Student ，该类中有两个公有成员变量 name 和 age ，分别表示学生的姓名和年龄，有两个公有成员函数study()和exam()。

第11～18行代码是在类外实现类的成员函数。

第21～23行代码，在 main() 函数中创建 Student 类对象 stu ，并设置对象 stu 的 name 和 age 值。

第24～26行代码通过对象stu调用对象的成员函数，输出对象stu的信息。

例2-2　package.cpp

xxxxxxxxxx
63
1
#include <iostream>
2
using namespace std;
3
class Student                           //定义学生类Student
4
{
5
public:                                 //公有类型
6
    void study();                       //声明表示学习的成员函数
7
    void exam();                        //声明表示考试的成员函数
8
    void setName(string name);          //声明设置姓名的成员函数
9
    void setAge(int age);               //声明设置年龄的成员函数
10
    string getName();                   //声明获取姓名的成员函数
11
    int getAge();                       //声明获取年龄的成员函数
12
private:                                //私有类型
13
    string _name;                       //声明表示姓名的成员变量
14
    int _age;                           //声明表示年龄的成员变量
15
};
16
void Student::study()                   //类外实现studey()成员函数
17
{
18
    cout << "学习C++" << endl;
19
}
20
void Student::exam()                    //类外实现exam()成员函数
21
{
22
    cout << "C++考试成绩100分" << endl;
23
}
24
void Student::setName(string name)      //类外实现setName()成员函数
25
{
26
    _name = name;
27
}
28
void Student::setAge(int age)           //类外实现setAge()成员函数
29
{
30
    if (age < 0 || age > 100)
31
    {
32
        cout << "_name" << "年龄输入错误" << endl;
33
        _age = 0;
34
    }
35
    else
36
        _age = age;
37
}
38
string Student::getName()               //类外实现getName()函数
39
{
40
    return _name;
41
}
42
int Student::getAge()                   //类外实现getAge()函数
43
{
44
    return _age;
45
}
46
int main()
47
{
48
    Student stu;                        //创建Student类对象stu
49
    stu.setName("张三");                  //设置对象stu的姓名
50
    stu.setAge(-20);                    //设置对象stu的年龄
51
    //调用成员函数getName()和getAge()获取对象stu的姓名、年龄，并输出
52
    cout << stu.getName() << stu.getAge() << "岁" << endl;
53
    stu.study();                        //调用成员函数study()
54
    stu.exam();                         //调用成员函数exam()
55
    Student stu1;                       //创建Student类对象stu1
56
    stu1.setName("李四");
57
    stu1.setAge(22);
58
    cout << stu1.getName() << stu1.getAge() << "岁" << endl;
59
    stu1.study();
60
    stu1.exam();
61
    return 0;
62
}
63

例2-2是对例2-1的修改，将Student中的成员变量name和age定义为私有成员，并定义了公有成员函数setNam e()、setAge()、getNam e()和getAge()，分别用于设置和获取对象的姓名和年龄。

第28～37行代码，在实现setAge()时，对传入的参数age进行了判断处理，如果age>100或age<0，则输出“年龄输入错误”的信息，并将 _age 值设置为0。

第48～52行代码，创建对象stu，调用 setName() 函数和 setAge() 函数，分别用于设置对象stu的 _name和 _age；调用 getName() 函数和 getAge() 函数，分别用于获取对象stu的 _name和 _age。

第56～60行代码，创建Student类对象stu1，设置其姓名和年龄，并获取对象stu1的姓名和年龄将其输出。

当设置对象stu的年龄为-20时，程序提示年龄输入错误，并将表示年龄的 _age设置为0；当设置对象stu1的 _age为22时，程序正确输出对象stu1的年龄。

在例2-2中， _name 和 _age 成员为私有成员，因此不能通过对象直接访问，如果仍然像例2-1中的第22～24行代码一样，直接通过对象访问 _name 和 _age，编译器会报错。

例2-3　noPara.cpp

xxxxxxxxxx
33
1
#include <iostream>
2
#include <iomanip>
3
using namespace std;
4
class Clock                     //定义时钟类Clock
5
{
6
public:
7
    Clock();                    //声明无参构造函数
8
    void showTime();            //声明显示时间的成员函数
9
private:
10
    int _hour;                  //声明表示小时的成员变量
11
    int _min;                   //声明表示分钟的成员变量
12
    int _sec;                   //声明表示秒的成员变量
13
};
14
Clock::Clock()                  //类外实现无参构造函数
15
{
16
    _hour=0;                    //初始化过程，将成员变量初始化为0
17
    _min=0;
18
    _sec=0;
19
}
20
void Clock::showTime()          //类外实现成员函数
21
{
22
    cout<<setw(2)<<setfill('0')<<_hour<<":"
23
            <<setw(2)<<setfill('0')<<_min<<":"
24
            <<setw(2)<<setfill('0')<<_sec<<endl;
25
}
26
int main()
27
{
28
    Clock clock;                //创建对象clock
29
    cout<<"clock：";
30
    clock.showTime();           //通过对象调用成员函数showTime()显示时间
31
    return 0;
32
}
33

在例2-3中，第7行代码声明了一个无参构造函数；

第14～19行代码在类外实现构造函数，在构造函数体中直接将初始值赋给成员变量；

第28～30行代码在main()函数中创建了对象clock，并通过对象调用showTime()成员函数显示初始化时间。

对象clock的初始化时间为00:00:00，因为创建clock对象调用的是无参构造函数，无参构造函数将时、分、秒都初始化为0。

例2-4　parameter.cpp

xxxxxxxxxx
37
1
#include <iostream>
2
#include <iomanip>
3
using namespace std;
4
class Clock                                     //定义时钟类Clock
5
{
6
public:
7
    Clock(int hour, int min, int sec);          //声明有参构造函数
8
    void showTime();                            //用于显示时间的成员函数
9
private:
10
    int _hour;                                  //声明表示小时的成员变量
11
    int _min;                                   //声明表示分钟的成员变量
12
    int _sec;                                   //声明表示秒的成员变量
13
};
14
Clock::Clock(int hour, int min, int sec)        //类外实现有参构造函数
15
{
16
    _hour=hour;                 //初始化过程，将初始值直接赋值给成员变量
17
    _min=min;
18
    _sec=sec;
19
}
20
void Clock::showTime()          //类外实现成员函数
21
{
22
    cout<<setw(2)<<setfill('0')<<_hour<<":"
23
                <<setw(2)<<setfill('0')<<_min<<":"
24
                <<setw(2)<<setfill('0')<<_sec<<endl;
25
}
26
int main()
27
{
28
    Clock clock1(10,20,30);     //创建对象clock1，传入初始值
29
    cout<<"clock1：";
30
    clock1.showTime();          //通过对象调用成员函数showTime()显示时间
31
    Clock clock2(22,16,12);     //创建对象clock2，传入初始值
32
    cout<<"clock2：";
33
    clock2.showTime();          //通过对象调用成员函数showTime()显示时间
34
    return 0;
35
}
36

37
在例2-4中，第7行代码声明了有参构造函数；

第14～19行代码在类外实现有参构造函数，将参数赋值给成员变量，在创建对象时调用有参构造函数，用户可以传入初始值（参数）完成对象初始化。

第28～33行代码，创建了两个Clock对象clock1和clock2，这两个对象在创建时，传入了不同的参数，因此各个对象调用成员函数showTime()显示的初始化时间是不一样的。

需要注意的是，在实现构造函数时，除了在函数体中初始化成员变量，还可以通过“：”运算符在构造函数后面初始化成员变量，这种方式称为列表初始化，其格式如下所示：

xxxxxxxxxx
4
1
类::构造函数(参数列表): 成员变量1(参数1)，成员变量2(参数2)，...，成员变量n(参数n)
2
{
3
    构造函数体
4
}

在例2-4中，使用列表初始化实现成员变量初始化的方式如下所示：

xxxxxxxxxx
4
1
Clock::Clock(int hour, int min, int sec):_hour(hour), _min(min), _sec(sec)
2
{
3
    //...
4
}

例2-5　overload.cpp

xxxxxxxxxx
41
1
#include <iostream>
2
#include <iomanip>
3
using namespace std;
4
class Clock                                     //定义时钟类Clock
5
{
6
public:
7
    //声明重载构造函数
8
    Clock(int hour, int min);
9
    Clock(int hour, int min, int sec=0); 
10
    void showTime();                            //声明显示时间的成员函数
11
private:
12
    int _hour;                                  //声明表示小时的成员变量
13
    int _min;                                   //声明表示分钟的成员变量
14
    int _sec;                                   //声明表示秒的成员变量
15
};
16
Clock::Clock(int hour, int min):_hour(hour),_min(min)
17
{
18
    cout<<"调用两个参数的构造函数"<<endl;
19
    _sec=10;
20
}
21
Clock::Clock(int hour, int min, int sec=0)      //类外实现构造函数
22
{
23
    cout<<"调用三个参数的构造函数"<<endl;
24
    _hour=hour;
25
    _min=min;
26
    _sec=sec;
27
}
28
void Clock::showTime()                          //类外实现成员函数showTime()
29
{
30
    cout<<setw(2)<<setfill('0')<<_hour<<":"
31
                <<setw(2)<<setfill('0')<<_min<<":"
32
                <<setw(2)<<setfill('0')<<_sec<<endl;
33
}
34
int main()
35
{
36
    Clock clock(8,0);                           //创建对象clock，传入初始值
37
    cout<<"clock：";
38
    clock.showTime();                           //通过对象调用成员函数显示时间
39
    return 0;
40
}
41

运行例2-5时，编译器会报错。

在例2-5中，第8行代码声明了一个构造函数，该构造函数有两个参数；

第9行代码声明了一个构造函数，该构造函数有三个参数，且第三个参数有默认值；

第16～27行代码，在类外实现了这两个构造函数；

第36行代码，在main()函数中创建一个对象clock，传入两个参数，编译器无法确认调用的是第8行的构造函数还是第9行的构造函数，因此无法通过编译。

例2-6　Student.cpp

xxxxxxxxxx
56
1
#include <iostream>
2
using namespace std;
3
class Birth                             //定义出生日期类Birth
4
{
5
public:
6
    Birth(int year,int month, int day);//构造函数
7
    void show();                        //声明成员函数show()显示日期
8
private:
9
    int _year;  
10
    int _month;
11
    int _day;
12
};
13
//类外实现构造函数
14
Birth::Birth(int year, int month, int day)
15
    :_year(year),_month(month),_day(day)
16
{
17
    cout<<"Birth类构造函数"<<endl;
18
}
19
//类外实现show()函数
20
void Birth::show()
21
{
22
    cout<<"出生日期："<<_year<<"-"<<_month<<"-"<<_day<<endl;
23
}
24
class Student                           //定义学生类Student
25
{
26
public:
27
    //构造函数
28
    Student(string name, int id, int year, int month, int day); 
29
    void show();
30
private:
31
    string _name;
32
    int _id;
33
    Birth birth;
34
};
35
//类外实现构造函数
36
Student::Student(string name, int id, int year, int month, int day)
37
    :birth(year,month,day)
38
{
39
    cout<<"Student类构造函数"<<endl;
40
    _name=name;
41
    _id=id;
42
}
43
//类外实现show()函数
44
void Student::show()
45
{
46
    cout<<"姓名："<<_name<<endl;
47
    cout<<"学号："<<_id<<endl;
48
    birth.show();
49
}
50
int main()
51
{
52
    Student stu("lili",10002,2000,1,1); //创建学生对象stu
53
    stu.show();                             //显示学生信息
54
    return 0;
55
}
56

在例2-6中，第3～12行代码定义了出生日期类Birth，该类有3个成员变量，分别是 _year、 _month、 _day，并且定义了有参数的构造函数；

第24～34行代码定义了学生类Student，该类有3个成员变量，分别是name、id、birth，其中birth是类Birth的对象。此外，Student类还定义了一个构造函数。由于成员对象birth的构造函数有3个参数，这3个参数要从类Student的构造函数中获取，因此Student类的构造函数共有5个参数。

第36～42行代码用于实现Student类的构造函数，birth成员对象必须通过“：”运算符在Student构造函数后面初始化，无法在Student构造函数体中赋值。

第52～53行代码，在main()函数中创建Student类对象stu，并通过对象stu调用成员函数show()显示学生信息。

创建对象stu时，先调用Birth类构造函数，之后才调用Student类构造函数。

例2-7　Rabbit.cpp

xxxxxxxxxx
40
1
#define _CRT_SECURE_NO_WARNINGS
2
#include <iostream>
3
using namespace std;
4
class Rabbit                                //定义兔子类Rabbit
5
{
6
public:
7
    Rabbit(string name,const char *pf); //声明构造函数
8
    void eat();
9
    ~Rabbit();                              //声明析构函数
10
private:
11
    string _name;                           //声明表示兔子名字的成员变量
12
    char *_food;                            //声明表示兔子食物的成员变量
13
};
14
Rabbit::Rabbit(string name, const char* pf)
15
{
16
    cout<<"调用构造函数"<<endl;
17
    _name=name;
18
    _food=new char[50];                     //为_food指针申请空间
19
    memset(_food,0,50);                     //初始化_food空间
20
    strcpy(_food,pf);                       //将参数pf指向的数据复制到_food中
21
}
22
void Rabbit::eat()
23
{
24
    cout<<_name<<" is eating "<<_food<<endl;
25
}
26
Rabbit::~Rabbit()                           //类外实现析构函数
27
{
28
    cout<<"调用析构函数，析构"<<_name<<endl;
29
    if(_food != NULL)
30
        delete []_food;
31
}
32
int main()
33
{
34
    Rabbit A("A","luobo");
35
    A.eat();
36
    Rabbit B("B","baicai");
37
    B.eat();
38
    return 0;
39
}
40

在例2-7中，第4～13行代码，定义了一个兔子类Rabbit，该类有两个成员变量，分别是name、food，有一个构造函数、一个析构函数和一个普通成员函数eat()；

第14～21行代码在类外实现构造函数。在实现构造函数时，由于第二个成员变量 _food是字符指针变量，因此在赋值时，要先使用 new运算符为 _food指针申请一块内存空间并初始化，再将参数pf指向的数据复制到 _food 指向的空间；

第22～25行代码在类外实现eat()函数；

第26～31行代码在类外实现析构函数，在析构函数中，使用delete运算符释放_food指向的内存空间。

第34～37行代码，在main()函数中，分别创建两个对象A和B，然后调用成员函数eat()实现吃食物的功能。

在创建对象的过程中，对象A与对象B除了对象本身所占用的内存空间，还各自拥有一块new运算符在堆上申请的空间。

程序运行结束后，编译器会调用析构函数释放对象资源，在释放时，先释放_food指向的内存空间，再释放对象所占用的内存空间。

程序调用析构函数析构的顺序是先析构对象B，再析构对象A。

例2-8　copy.cpp

xxxxxxxxxx
45
1
#include <iostream>
2
using namespace std;
3
class Sheep                             //定义绵羊类Sheep
4
{
5
public:
6
    Sheep(string name,string color);    //声明带参数构造函数
7
    Sheep(const Sheep& another);        //声明拷贝构造函数
8
    void show();                        //声明普通成员函数
9
    ~Sheep();                           //声明析构函数
10
private:
11
    string _name;                       //声明表示绵羊名字的成员变量
12
    string _color;                      //声明表示绵羊颜色的成员变量
13
};
14
Sheep::Sheep(string name, string color)
15
{
16
    cout<<"调用构造函数"<<endl;
17
    _name=name;
18
    _color=color;
19
}
20
Sheep::Sheep(const Sheep& another)      //类外实现拷贝构造函数
21
{
22
    cout<<"调用拷贝构造函数"<<endl;
23
    _name=another._name;
24
    _color=another._color;
25
}
26
void Sheep::show()
27
{
28
    cout<<_name<<" "<<_color<<endl;
29
}
30
Sheep::~Sheep()
31
{
32
    cout<<"调用析构函数"<<endl;
33
}
34

35
int main()
36
{
37
    Sheep sheepA("Doly","white");
38
    cout<<"sheepA:";
39
    sheepA.show();
40
    Sheep sheepB(sheepA);               //使用sheepA初始化新对象sheepB
41
    cout<<"sheepB:";
42
    sheepB.show();
43
    return 0;
44
}
45

在例2-8中，第3～13行代码定义了一个绵羊类Sheep，该类有两个成员变量，分别是 _name、 _color。此外，该类还声明了有参构造函数、拷贝构造函数、普通成员函数show()和析构函数；

第20～25行代码，在类外实现拷贝构造函数，在函数体中，将形参sheepA的成员变量值赋给类的成员变量；

第37～39行代码，在main()函数，创建了Sheep类对象sheepA，并输出sheepA的信息；

第40行代码创建Sheep类对象sheepB，并使用对象sheepA初始化对象sheepB，在这个过程中编译器会调用拷贝构造函数；

第41～42行代码输出对象sheepB的信息。

对象sheepA与对象sheepB的信息是相同的。程序首先调用构造函数创建了对象sheepA，然后调用拷贝构造函数创建了对象sheepB。程序运行结束之后，调用析构函数先析构对象sheepB，然后析构对象sheepA。

例2-9　simple.cpp

xxxxxxxxxx
56
1
#define _CRT_SECURE_NO_WARNINGS
2
#include <iostream>
3
#include <string.h>
4
using namespace std;
5
class Sheep                                             //定义绵羊类Sheep
6
{
7
public:
8
    Sheep(string name,string color,const char*home);    //声明带参数构造函数
9
    Sheep(const Sheep& another);                        //声明拷贝构造函数
10
    void show();                                        //声明普通成员函数
11
    ~Sheep();                                           //声明析构函数
12
private:
13
    string _name;                           //声明表示绵羊名字的成员变量
14
    string _color;                          //声明表示绵羊颜色的成员变量
15
    char* _home;                            //声明表示绵羊家的成员变量
16
};
17
Sheep::Sheep(string name, string color,const char*home)
18
{
19
    cout<<"调用构造函数"<<endl;
20
    _name=name;
21
    _color=color;
22
    //为指针成员home分配空间，将形参home的内容复制到_home指向的空间
23
    int len=strlen(home)+1;
24
    _home=new char[len];
25
    memset(_home,0,len);
26
    strcpy(_home,home);
27
}
28
Sheep::Sheep(const Sheep& another)      //类外实现拷贝构造函数
29
{
30
    cout<<"调用拷贝构造函数"<<endl;
31
    _name=another._name;
32
    _color=another._color;
33
    _home=another._home;                //浅拷贝
34
}
35
void Sheep::show()
36
{
37
    cout<<_name<<" "<<_color<<" "<<_home<<endl;
38
}
39
Sheep::~Sheep()
40
{
41
    cout<<"调用析构函数"<<endl;
42
    if(_home!=NULL)
43
        delete []_home;
44
}
45
int main()
46
{
47
    const char *p = "beijing";
48
    Sheep sheepA("Doly","white",p);
49
    cout<<"sheepA:";
50
    sheepA.show();
51
    Sheep sheepB(sheepA);               //使用sheepA初始化新对象sheepB
52
    cout<<"sheepB:";
53
    sheepB.show();
54
    return 0;
55
}
56

运行例2-9中的程序，程序抛出异常，在第43行代码处触发异常断点。

例2-9是对例2-8的修改，在绵羊类Sheep中增加了一个char类型的指针变量成员 _home，用于表示绵羊对象的家。增加了 _hom e成员变量之后，类Sheep的构造函数、拷贝构造函数、析构函数都进行了相应修改。

第17～27行代码实现构造函数，在构造函数内部，首先为_home指针申请堆内存空间，然后调用strcpy()函数将形参home的内容复制到 _home指向的空间。

第28～34行代码实现拷贝构造函数，在拷贝构造函数内部，对指针成员只进行了简单的赋值操作，即浅拷贝。

第39～44行代码实现析构函数，在析构函数内部，使用delete运算符释放_home指向的内存空间。

第47～53行代码，在main()函数中，先创建对象sheepA，再创建对象sheepB，并用对象sheepA初始化对象sheepB。

在这个过程中，使用对象sheepA初始化对象sheepB是浅拷贝过程，因为对象sheepB的 _home指针指向的是对象sheepA的 _home指针指向的空间。

在浅拷贝过程中，对象sheepA中的 home指针与对象sheepB中的 _ home指针指向同一块内存空间。当程序运行结束时，析构函数释放对象所占用资源，析构函数先析构对象sheepB，后析构对象sheepA。在析构sheepB对象时释放了home指向的堆内存空间的数据，当析构sheepA时_home指向的堆内存空间已经释放，再次释放内存空间的资源，程序运行异常终止，即存储“beijing”的堆内存空间被释放了两次，因此程序抛出异常，这种现象被称重析构（double free）。

例2-10　constMember.cpp

xxxxxxxxxx
29
1
#include <iostream>
2
using namespace std;
3
class Person                    //定义类Person
4
{
5
public:
6
    Person(string name,int age,string addr);  //声明带参构造函数
7
    const string _addr;         //声明表示住址的常成员变量
8
    ~Person();                  //声明析构函数
9
private:
10
    const string _name;         //声明表示姓名的常成员变量
11
    const int _age;             //声明表示年龄的常成员变量
12
};
13
//类外实现构造函数
14
Person::Person(string name,int age,string addr):
15
    _name(name),_age(age),_addr(addr)
16
{
17
    cout<<"初始化const修饰的成员变量"<<endl;
18
    cout<<"name:"<<_name<<endl;
19
    cout<<"age:"<<_age<<endl;
20
    cout<<"addr:"<<_addr<<endl;
21
}
22
Person::~Person(){}             //类外实现析构函数
23
int main()
24
{
25
    Person p1("张三",18,"北大街");
26
     p1._addr="南大街";
27
    return 0;
28
}
29

运行例2-10，编译器会报错

在例2-10中，第3～12行代码定义了一个类Person，该类有三个常成员变量： _name、 _age和 _addr。

第14～21行代码，在类外实现类的构造函数，类的常成员变量在构造函数中完成初始化，即创建对象时完成初始化。

第25行代码创建Person类对象p1，在创建对象时完成了三个常成员变量的初始化。这是创建对象后初始化常成员变量的唯一机会，常成员变量一旦初始化就不能再改变。第26行代码试图修改常成员变量，因此程序会报错。

例2-11　constFunc.cpp

xxxxxxxxxx
48
1
#include <iostream>
2
using namespace std;
3
class  Person                           //定义类Person
4
{
5
public:
6
    Person(string ,int,string,string); //声明带参构造函数
7
    ~Person();                          //声明析构函数
8
    const string _addr;                 //声明表示住址的常成员变量
9
    void  myInfor() const;              //声明显示个人信息的常成员函数
10
    void  myInfor();                    //声明显示个人信息的普通成员函数
11
    void place();                       //声明显示住址的普通成员函数
12
private:
13
    const string _name;                 //声明表示姓名的常成员变量
14
    const int _age;                     //声明表示年龄的常成员变量
15
    string _favFruit;                   //声明表示水果的普通成员变量
16
};
17
//有参构造函数初始化对象
18
Person::Person(string name,int age,string addr,string favFruit):
19
    _name(name), _age(age),_addr(addr),_favFruit(favFruit)
20
{
21
}
22
void Person::myInfor() const            //类外实现常成员函数myInfor()
23
{
24
    //_favFruit="榴莲";
25
    //place();
26
    cout<<"我叫"<<_name<<"今年"<<_age<<"岁"<<"我喜欢吃"<<_favFruit<<endl;  
27
}
28
Person:: ~Person(){}                    //类外实现析构函数
29
void Person::myInfor()                  //类外实现普通成员函数myInfor()
30
{
31
    _favFruit="桃子";
32
    cout<<"我叫"<<_name<<"今年"<<_age
33
        <<"岁"<<"我喜欢吃"<<_favFruit<<endl; 
34
    place();
35
}
36
void Person::place()                    //类外实现普通成员函数place()
37
{
38
    cout<<"我住在"<<_addr<<endl;
39
}
40
int main()
41
{
42
    Person p1("张三",18,"北大街","苹果");          //创建对象p1
43
    p1.myInfor();                               //调用普通成员函数myInfor()
44
    const Person p2("李四",18,"南大街","橘子");    //创建常对象p2
45
    p2.myInfor();                               //调用常成员函数myInfor()
46
    return 0;
47
}
48

在例2-11中，第3～16行代码定义了Person类，该类中定义了三个成员变量，其中 _name和 _age是常成员函数。

此外，第9～10行代码声明了Person类两个重载的成员函数myInfor()，第9行代码的myInfor()函数为常成员函数，第10行代码的myInfor()函数为普通成员函数。

第22～27行代码在类外实现常成员函数myInfor()，在函数内部，输出各个成员变量的值。需要注意的是，类的常成员函数不能修改成员变量的值，也不能调用非常成员函数，如第24～25行代码，如果取消注释，程序就会报错。

第29～35行代码在类外实现普通成员函数myInfor()，在函数内部，可以像第31行代码那样修改成员变量的值，也可以像第34行代码那样调用非常成员函数。

第42～43行代码创建对象p1，并通过p1调用myInfor()函数，由图2-16可知，对象p1调用的是普通成员函数m yInfor()。

第44～45行代码创建常对象p2，并通过p2调用myInfor()，由图2-16可知，常对象p2成功调用了常成员函数myInfor()。

例2-12　staticMember.cpp

xxxxxxxxxx
30
1
#include <iostream>
2
using namespace std;
3
class Student                           //定义学生类Student
4
{
5
public:
6
    Student(string name);               //声明带参构造函数
7
    ~Student();                         //声明析构函数
8
     static int _sum;                   //声明表示学生总数的静态成员变量
9
private:
10
    string _name;                       //声明表示学生姓名的成员变量
11
};
12
//类外实现Student类带参数的构造函数
13
Student::Student(string name)
14
{
15
    this->_name=name;
16
    _sum++;   
17
}
18
Student::~Student(){}                   //类外实现析构函数
19
int Student::_sum = 0;                  //类外初始化静态成员变量_sum
20
int main()
21
{
22
    Student stu1("张三");
23
    Student stu2("李四");
24
    cout<<"人数是:"<<stu1._sum<<endl;  //通过对象访问静态成员变量
25
    cout<<"人数是:"<<stu2._sum<<endl;
26
     cout<<"人数是"<<Student::_sum<<endl;//通过类访问静态成员变量
27
     cout<<"stu1的大小是:"<<sizeof(stu1)<<endl;
28
    return 0;
29
}
30

在例2-12中，第3～11行代码定义了学生类Student，其中，第8行代码定义了静态成员变量sum。

第13～17行代码在类外部实现有参构造函数，每当创建对象时，sum的值自动加1，用于统计建立Student类对象的数目。

第19行代码在类外部初始化sum的值为0。

第22～23行代码创建了两个对象stu1和stu2。

第24～25行代码通过对象stu1和stu2访问静态成员变量 _sum，对象stu1和对象stu2访问到的静态成员变量 _sum值均为2。

第26行代码通过类的作用域访问静态成员变量sum，通过类的作用域访问到的静态成员变量sum值也为2。

第27行代码计算对象stu1的大小，对象stu1的大小为28，静态成员变量并不包含在对象中。

例2-13　staticFunc.cpp

xxxxxxxxxx
35
1
#include <iostream>
2
#include <math.h>
3
using namespace std;
4
class Point
5
{
6
public:
7
    Point (float x,float y);
8
    ~Point();
9
    static float getLen(Point &p1,Point &p2);
10
    static float _len; 
11
private:
12
    float _x;
13
    float _y;
14
};
15
float Point::_len=0;
16
Point::Point(float x=0,float y=0):_x(x),_y(y)
17
{
18
    cout<<"初始化坐标点"<<endl;
19
}
20
Point::~Point(){}
21
float Point::getLen(Point &p1,Point &p2)
22
{
23
    float x=abs(p1._x-p2._x);
24
    float y=abs(p1._y-p2._y);
25
    _len=sqrtf(x*x+y*y);
26
    return _len;
27
}
28
int main()
29
{
30
    Point p1(1,2);
31
    Point p2(6,8);
32
    cout<<Point::getLen(p1,p2)<<endl;
33
    return 0;
34
}
35

例2-13中，第4～14行代码定义了类Point，其中，第9行代码定义了静态成员函数getLen()，用于获取两个坐标点之间的距离；第10行代码定义了静态成员变量len，用于存储两个坐标点之间的距离。

第16～19行代码在类外实现有参构造函数，初始化坐标点的值，默认值为0。

第21～27行代码，在类外实现getLen()函数，计算传入的两个坐标p1和p2之间的距离，并将结果保存到变量_len中。

第30～31行代码初始化坐标点p1和p2。

第32行代码调用getLen()函数计算两个坐标点之间的距离。

例2-14　friendFunc.cpp

xxxxxxxxxx
33
1
#include <iostream>
2
using namespace std;
3
class Circle
4
{
5
friend void getArea(Circle &circle);    //声明普通函数getArea()为友元函数
6
private:
7
    float _radius;
8
    const float PI=3.14;
9
public:
10
    Circle(float radius);
11
    ~Circle();
12
};
13
Circle::Circle(float radius=0):_radius(radius)
14
{
15
    cout<<"初始化圆的半径为："<<_radius<<endl;
16
}
17
Circle::~Circle(){}
18
void getArea(Circle &circle)
19
{
20
     //访问类中的成员变量
21
    cout<<"圆的半径是："<<circle._radius<<endl;
22
    cout<<"圆的面积是"<<circle.PI*circle._radius*circle._radius<<endl;
23
    cout<<"友元函数修改半径:"<<endl;
24
    circle._radius=1;
25
    cout<<"圆的半径是："<<circle._radius<<endl;
26
} 
27
int main()
28
{
29
    Circle circle(10);
30
    getArea(circle);
31
    return 0;
32
}
33

在例2-14中，第3～12行代码定义了关于圆的类Circle，其中圆的半径_radius和圆周率PI是私有成员；

第5行代码在类中声明了友元函数getArea()，用于计算圆的面积；

第18～26行代码是getArea()函数的实现；

第29行代码创建对象circle，并初始化圆的半径为10；

第30行代码调用友元函数getArea()计算圆的面积，面积计算完成后，修改圆的半径为1。

普通函数作为友元函数访问了类中的私有成员，且具有修改私有成员的权限。

例2-15　friendMember.cpp

xxxxxxxxxx
45
1
#include <iostream>
2
#include <math.h>
3
using namespace std;
4
class Point;
5
class Circle
6
{
7
public:
8
    float getArea(Point &p1,Point &p2);         //声明计算面积的成员函数
9
private:
10
    const float PI=3.14;
11
};
12
class Point
13
{
14
//声明类Circle的getArea()函数为友元函数声明
15
friend float Circle::getArea(Point &p1,Point &p2);  
16
public:
17
    Point (float x,float y);
18
    ~Point();
19
private:
20
    float _x;
21
    float _y;
22
};
23
Point::Point(float x=0,float y=0):_x(x),_y(y)   //实现Point类的构造函数
24
{
25
    cout<<"初始化坐标点"<<endl;
26
}
27
Point::~Point(){}
28
float Circle::getArea(Point &p1,Point &p2)
29
{
30
    double x=abs(p1._x-p2._x);                  //获取横轴坐标间的距离
31
    float y=abs(p1._y-p2._y);                   //获取纵轴坐标间的距离
32
    float len=sqrtf(x*x+y*y);                   //计算两个坐标点之间的距离
33
    cout<<"获取两个坐标点之间的距离是"<<len<<endl;
34
    return len*len*PI;                          //友元函数访问私有成员变量PI
35
}
36
int main()
37
{
38
    Point p1(5,5);
39
    Point p2(10,10);
40
    Circle circle;
41
    float area=circle.getArea(p1,p2);
42
    cout<<"圆的面积是："<<area<<endl;
43
    return 0;
44
}
45