[C++ Primer Plus] 第8章、函数探幽——（一）程序清单

8.1 C++内联函数

内联函数时C++为提高程序运行速度所做的一项改进，常规函数和内联函数的主要区别不在于编写方式，而在于C++编译器如何将它们组合到程序中。

编译过程的最终产品是可执行程序——由一组机器语言指令组成。运行程序时，操作系统将这些指令载入到计算机内存中，因此每条指令都有特定的内存地址。执行常规函数调用时，程序将在函数调用后立即存储该指令的内存地址，并将函数参数复制到堆栈，跳到标记函数起点的内存单元，执行函数代码（也许还需将返回值放入寄存器中），然后跳回到地址被保存的指令处，来回跳跃需要一定的开销。

对于内联函数，编译器将使用相应的函数代码替换函数调用，程序无需跳到另一个位置处执行代码，再跳回来。因此，内联函数的运行速度比常规函数稍快，但代价时需要占用更多的内存。

如果执行函数代码的时间比处理函数调用机制的时间长，则节省的时间只占很小一部分。如果执行代码时间很短，则内联调用可节省相对来说的大部分时间，但节省的时间绝对值并不大，除非该函数经常被调用。

写代码时，通常做法，是省略函数原型，直接将整个函数定义放在main（）的前面，并在函数定义前加上关键字inline。该内联函数不能过长，且不能递归。

#include<iostream>
using namespace std;

inline double square(double x) //inline表示内联函数
{
    return x*x;
}

int main()
{
    double a, b, c = 13.0;
    a = square(5.0);
    b = square(4.5 + 7.5);
    cout << "a=" << a << ",b=" << b << endl;
    cout << "c=" << c << ",c square=" << square(c++) << endl;
    cout << "Now c=" << c << endl;
    system("pause");
    return 0;
}

 

 

 

8.2 引用变量

8.2.1 创建引用变量

 引用是已定义的变量的别名。引用变量的主要用途是用作函数的形参，通过将引用变量作为参数，函数将使用原始数据，而不是其副本。这样除指针外，引用也为函数处理大型结构提供了一种非常方便的途径，同时对于设计类来说，引用也是必不可少的。

必须在声明引用变量时进行初始化。

#include<iostream>
using namespace std;

int main()
{
    int rates = 101;
    int &rodents = rates;   //将rodents的类型声明为int&，即指向int变量的引用
    cout << "rates= " << rates;
    cout << ",rodents= " << rodents << endl;
    rodents++;
    cout << "rates= " << rates;
    cout << ",rodents= " << rodents << endl;
    cout << "rates address= " << &rates << endl;
    cout << "rodents address= " << &rodents << endl;
    cout << "****************************" << endl;
    int bunnies = 50;
    rodents = bunnies;
    cout << "bunnies= " << bunnies;
    cout << ",rates= " << rates;
    cout << ",rodents= " << rodents << endl;
    cout << "rates address= " << &rates << endl;      //rates和rodents的地址相同
    cout << "rodents address= " << &rodents << endl;   
    cout << "bunnies address= " << &bunnies << endl;

    system("pause");
    return 0;
}

 

将rodents初始化为*pt使得rodents指向rates，接下来将pt改为指向bunnies，并不能改变rodents引用的是rates。

#include<iostream>
using namespace std;

int main()
{
    int rates = 101;
    int *pt = &rates;
    int &rodents = *pt;
    cout << rates << ' ' << rodents << ' ' << *pt << endl;
    int bunnies = 50;
    pt = &bunnies;
    cout << rates << ' ' << rodents << ' ' << *pt << endl;
    system("pause");
    return 0;
}

 8.2.2 将引用用作函数参数

 按引用传递：使得函数中的变量名成为调用程序中的变量的别名。

按引用传递允许被调用的函数能够访问调用函数中的变量。

 

 8.2.3 引用的属性和特别之处

临时变量、引用参数和const

如果实参与引用参数不匹配，仅当参数为const引用时，C++将生成临时变量。

 

 

 参数side，lens[2]，rd和*pd都是有名称的，double类型的数据对象，因此可以为其创建引用，而不需要临时变量。然而，edge虽然是变量，类型却不正确，double引用不能指向long；参数7.0和side+10.0的类型都正确，但没有名称，在这些情况下，编译器都将生成一个临时匿名变量，并让ra指向它。这些临时变量只在函数调用期间存在，此后编译器便可以随意将其删除。

 8.2.4将引用用于结构

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

struct free_throws
{
    string name;
    int made;
    int attempts;
    float percent;
};

void display(const free_throws &ft);
void set_pc(free_throws &ft);
free_throws & accumulate(free_throws &target, const free_throws &source);  //返回类型为free_throws &（引用），所以返回的不是target，而是最初传递给accumulate（）的team对象

int main()
{
    free_throws one = { "If Branch", 13, 14 };
    free_throws two = { "Andor Knott", 10, 16 };
    free_throws three = { "Min Max", 7, 9 };
    free_throws four = { "Whi Loo", 5, 9 };
    free_throws five = { "Long Long", 6, 14 };
    free_throws team = { "Throw", 0, 0 };
    free_throws dup;

    set_pc(one);
    display(one);
    accumulate(team, one);
    display(team);
    display(accumulate(team, two));
    accumulate(accumulate(team, three), four);
    display(team);
    dup = accumulate(team, five);       //如果accumulate（）返回一个结构，而不是指向结构的引用，将把整个结构复制到一个临时位置，再将这个拷贝复制给dup。但在返回值为引用时，将直接把team复制到dup，其效率更高
    cout << "Displaying team: " << endl;
    display(team);
    cout << "Displaying dup after assignment: " << endl;
    display(dup);
    set_pc(four);
    accumulate(dup, five) = four;     //four赋给dup
    cout << "Displaying dup after ill-advised assignment:" << endl;
    display(dup);
    system("pause");
    return 0;
}

void display(const free_throws &ft)
{
    cout << "Name: " << ft.name << endl;
    cout << "Made: " << ft.made << "\t";
    cout << "Attempts: " << ft.attempts << "\t";
    cout << "Percent: " << ft.percent << endl;
}

void set_pc(free_throws &ft)
{
    if (ft.attempts != 0)
        ft.percent = 100.0f*float(ft.made) / float(ft.attempts);
    else
        ft.percent = 0;
}

free_throws & accumulate(free_throws &target, const free_throws &source)
{
    target.attempts += source.attempts;
    target.made += source.made;
    set_pc(target);
    return target;
}

返回引用时需要注意的问题：

 返回引用时最重要的一点是，应避免返回函数终止时不再存在的内存单元引用。所以应避免编写以下代码：

const free_throws & clone2(free_throws & ft)
{
      free_throws newguy;
      newguy = ft;
      return newguy;
}

该函数返回一个指向临时变量（newguy）的引用，函数运行完毕后它将不再存在。同样，也应避免返回指向临时变量的指针。

为避免这种问题，最简单的方法是，返回一个作为参数传递给函数的引用。上面的accumulate（）正是这样做的。

另一种方法是用new来分配新的存储空间。前面见过这样的函数，它使用new为字符串分配内存空间，并返回指向该内存空间的指针。

const free_throws & clone(free_throws & ft)
{
       free_throws *pt;
       *pt = ft;
       return *pt;
}

让指针pt指向该结构，因此*pt就是该结构。上述代码似乎会返回该结构，但函数声明表明，该函数实际上将返回这个结构的引用。这样便可以这样使用该函数：

free_throws & jolly=clone(three);

这使得jolly成为新结构的引用，不过这种存在一个问题：调用clone（）隐藏了对new的调用，这使得以后很容易忘记使用delete来释放内存。

8.2.5 将引用用于类对象

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

string version1(const string &s1, const string &s2);
const string & version2(string &s1, const string &s2);
const string & version3(string &s1, const string &s2);

int main()
{
    string input;
    string copy;
    string result;
    cout << "Enter a string: ";
    getline(cin, input);
    copy = input;       //C++中，string可以直接赋值
    cout << "Your string as entered: " << input << endl;
    result = version1(input, "***");                    //"***"是char *型，但可用于const string &的形参。此处2点需说明：1.string类定义了一种char*到string的转换功能，这使得可以使用C-风格字符串来初始化string对象。
                                                        //2.前面提到过的如果引用参数是const，编译器在实参的类型不正确，但可以转换为正确的类型的情况下生成临时变量，使用转换后的实参值来初始化它，然后传递一个指向该临时变量的引用。
    cout << "Your string enhanced: " << result << endl;
    cout << "Your original string: " << input << endl;

    result = version2(input, "***");
    cout << "Your string enhanced: " << result << endl;
    cout << "Your original string: " << input << endl;

    cout << "Resetting original string." << endl;
    input = copy;
    result = version3(input, "@@@");
    cout << "Your string enhanced: " << result << endl;
    cout << "Your original string: " << input << endl;

    system("pause");
    return 0;
}

string version1(const string &s1, const string &s2)
{
    string temp;
    temp = s2 + s1 + s2;
    return temp;         //返回main函数时，tmp不复存在，但tmp的内容被复制到临时存储单元
}

const string & version2(string &s1, const string &s2)   //改变了s1的内容
{
    s1 = s2 + s1 + s2;
    return s1;
}

const string & version3(string &s1, const string &s2)
{
    string temp;
    temp = s2 + s1 + s2;
    return temp;        //返回main函数时，tmp内存已被释放，程序不能引用已经释放的内存
}

 此时该程序已经崩溃。

8.2.6 对象、继承和引用

 正如第6章介绍的，ofstream对象（文件用于处理输出的类）可以使用ostream类（控制台用于处理输出的类）的方法，这使得文件输入/输出的格式与控制台输入/输出相同。ostream是基类，ofstream是派生类，派生类继承了基类的方法，这意味着ofstream对象可以使用基类的特性。

继承的另一个特征是，基类引用可以指向派生类对象，而无需进行强制类型转换。这种特征的一个实际结果是，可以定义一个接受基类引用作为参数的函数，调用该函数时，可以将基类对象作为参数，也可以将派生类对象作为参数。

#include <iostream>
#include <fstream>
#include <cstdlib>      //支持exit()函数
using namespace std;

void file_it(ostream &os, double fo, const double fe[], int n);
const int LIMIT = 5;
int main()
{
    ofstream fout;
    const char *fn = "ex-data.txt";
    fout.open(fn);        //若程序运行前ex-data.txt不存在，open()将新建一个名为ex-data.txt的文件；若程序运行前存在，open()将首先截断该文件，即将长度截短到0，丢其原来所有内容，然后将新的输出加入到该文件中
    if (!fout.is_open())    //打开文件失败
    {
        cout << "Can't open " << fn << ".Bye.\n";
        exit(EXIT_FAILURE);    //异常退出
    }
    double objective;
    cout << "Enter the focal length of your "
        "telescope objective in mm: ";
    cin >> objective;
    double eps[LIMIT];
    cout << "Enter the focal lengths, in mm, of " << LIMIT << " eyepieces: \n";
    for (int i = 0; i < LIMIT; i++)
    {
        cout << "Enter #" << i + 1 << ": ";
        cin >> eps[i];
    }
    file_it(fout, objective, eps, LIMIT);       //将数据写入文件
    file_it(cout, objective, eps, LIMIT);       //将同样的信息以相同的格式显示到屏幕上
    cout << "Done\n";
    return 0;
}

void file_it(ostream &os, double fo, const double fe[], int n)
{
    ios_base::fmtflags initial;   //ios_base::fmtflags是储存这种信息所需的数据类型名称,initial存储调用file_it()之前的格式化设置
    //setf()方法能够设置各种格式化状态
    initial = os.setf(ios_base::fixed);    //set(ios_base::fixed)将对象置于使用定点表示法的模式
    os.precision(0);                       //指定显示多少位小数（假定对象处于定点模式下）
    os << "Focal length of objective: " << fo << " mm\n";
    os.setf(ios::showpoint);               //将对象置于显示小数点的模式，即使小数部分为零
    os.precision(1);
    os.width(12);
    os << "f.l. eyepiece";
    os.width(12);
    os << "magnification" << endl;
    for (int i = 0; i < n; i++)
    {
        os.width(12);
        os << fe[i];
        os.width(15);
        os << int(fo / fe[i] + 0.5) << endl;
    }
    os.setf(initial);       //使用initial作为参数来调用setf()，将返回调用file_it()之前有效的所有格式化设置
}

 

 

 

以下是一些常见的控制函数的: 
dec 置基数为10 相当于"%d" 
hex 置基数为16 相当于"%X" 
oct 置基数为8 相当于"%o" 
setfill(c) 设填充字符为c 
setprecision(n) 设显示小数精度为n位 
setw(n) 设域宽为n个字符

setioflags(ios::fixed) 固定的浮点显示 
setioflags(ios::scientific) 指数表示 
setiosflags(ios::left) 左对齐 
setiosflags(ios::right) 右对齐 
setiosflags(ios::skipws 忽略前导空白 
setiosflags(ios::uppercase) 16进制数大写输出 
setiosflags(ios::lowercase) 16进制小写输出 
setiosflags(ios::showpoint) 强制显示小数点 
setiosflags(ios::showpos) 强制显示符号

8.3 默认参数

默认参数指的是当函数调用中省略了实参时自动使用的一个值。

注意：只有函数原型指定了默认值，函数定义与没有默认参数时完全相同。

 

#include <iostream>
using namespace std;
const int ArzSize = 80;
char *left(const char *str, int n = 1);

int main()
{
    char sample[ArzSize];
    cout << "Enter a string: \n";
    cin.get(sample, ArzSize);
    char *ps = left(sample, 4);
    cout << ps << endl;         //如果给cout提供一个指针，它将打印地址，但如果这个指针类型是char *，则cout将显示指向的字符串；若要显示地址，则应cout<<(int *)ps；如果couot<<*ps，则只会显示字符串的第一个字符
    delete[]ps;
    ps = left(sample);
    cout << ps << endl;
    delete[]ps;
    return 0;

}

char *left(const char *str, int n)         //内部使用了new没有delete，所以main函数调用此方法后一定要记得delete
22 {
    if (n < 0)
        n = 0;
    char *p = new char[n + 1];         //new和delete成对出现
    int i;
    for (i = 0; i < n && str[i]; i++)
    {
        p[i] = str[i];
    }
    while(i<=n)
        p[i++] = '\0';
    return p;
}

 

8.4 函数重载

默认参数让你能够使用不同数目的参数调用同一个函数。而函数多态（函数重载）让你能够使用多个同名的函数，“多态”指的是有多种形式，因此函数多态允许函数可以有多种形式。

C++允许定义名称相同的函数，条件是它们的特征标不同。函数的参数列表（也称为函数特征标）：参数数目、参数类型、排列顺序。如果参数数目和/或参数类型不同，则特征标也不同。

#include <iostream>
using namespace std;

unsigned long left(unsigned long num, unsigned ct);
char * left(const char *str, int n = 1);

int main()
{
    char *trip = "Hawaii!!";
    unsigned long n = 12345678;
    int i;
    char *temp;

    for (i = 1; i < 10;i++)
    {
        cout << left(n, i) << endl;
        temp = left(trip, i);
        cout << temp << endl;
        delete []temp;              //此处delete
    }
    retuen 0;22     system("pause");         //这里写反了，stystem应该在return 0前面
}

unsigned long left(unsigned long num, unsigned ct)
{
    unsigned digits = 1;
    unsigned long n = num;
    
    if (ct == 0 || num == 0)
        return 0;
    while (n /= 10)
    {
        digits++;
    }
    if (digits > ct)
    {
        ct = digits - ct;
        while (ct--)
            num /= 10;
        return num;
    }
    else
        return num;
}

char * left(const char *str, int n)        //内部使用了new没有delete，所以main调用后一定要记得delete
{
    if (n < 0)
        n = 0; 
    char *p = new char[n + 1];          //new和delete成对出现
    int i;
    for (i = 0; i < n && str[i];i++)
    {
        p[i] = str[i];
    }
    while (i <= n)
        p[i++] = '\0';
    return p;
}

 

 8.5 函数模板

函数模板是通用的函数描述，也就是说，它们使用泛型来定义函数，其中的泛型可用具体的类型（如int或double）替换。

如果需要多个将同一种算法用于不同类型的函数，请使用模板。

#include <iostream>
using namespace std;

template<typename T>    //函数模板
void Swap(T &a, T &b);    //不能用swap函数名，用户自己定义的swap()和STL库定义的函数重装冲突

int main()
{
    int i = 10, j = 20;
    cout << "i,j= " << i << "," << j << endl;
    Swap(i, j);
    cout << "Now i,j= " << i << "," << j << endl;

    double x = 24.5, y = 81.7;
    cout << "x,y= " << x << "," << y << endl;
    Swap(x, y);
    cout << "Now x,y= " << x << "," << y << endl;

    system("pause");
    return 0;
}

template<typename T>      //要记得写在这里
void Swap(T &a, T &b)
{
    T temp;
    temp = a;
    a = b;
    b = temp;
}

8.5.1 重载的模板

#include <iostream>
using namespace std;

template<typename T>    //函数模板
void Swap(T &a, T &b);    //不能用swap函数名，用户自己定义的swap()和STL库定义的函数重装冲突

template<class T>       //模板的另一种表示方式
void Swap(T *a, T *b, int n);

void show(int a[]);
const int Lim = 8;

int main()
{
    int i = 10, j = 20;
    cout << "i,j= " << i << "," << j << endl;
    Swap(i, j);
    cout << "Now i,j= " << i << "," << j << endl;

    int d1[Lim] = { 0,7,0,4,1,7,7,6 };
    int d2[Lim] = { 0,7,2,0,1,9,6,9 };
    cout << "Original arrays: " << endl;
    show(d1);
    show(d2);
    Swap(d1, d2, Lim);
    cout << "Swap arrays: " << endl;
    show(d1);
    show(d2);

    system("pause");
    return 0;
}

template<class T>
void Swap(T &a, T &b)
{
    T temp;
    temp = a;
    a = b;
    b = temp;
}

template<typename T>
void Swap(T *a, T *b, int n)
{
    T temp;
    for (int i = 0; i < n; i++)
    {
        temp = a[i];
        a[i] = b[i];
        b[i] = temp;
    }
}

void show(int a[])
{
    cout << a[0] << a[1] << "/";
    cout << a[2] << a[3] << "/";
    for (int i = 4; i < Lim; i++)
    {
        cout << a[i];
    }
    cout << endl;
}

 8.5.3 显式具体化

需要显式具体化的情况：

假设定义了如下结构：

struct job
{
char name[40];
double salary;
int floor;
};

假设希望能交换两个这种结构的内容，原来的模板使用下面的代码来完成交换：

temp = a;
a = b;
b = temp;

但是如果只想交换salary和floor成员，而不想交换name成员，则需要使用不同的代码，但Swap()的参数将保持不变，因此无法使用模板重载来提供其他的代码，这样就有了显示具体化。

可以提供一个具体化函数定义，称为显式具体化，其中包含所需代码， 当编译器找到与函数调用匹配的具体化定义时，将使用该定义，而不在寻找模板。

• 对于给定的函数名，可以有非模板函数、模板函数和显式具体化模板函数以及它们的重载版本。
• 显式具体化的原型和定义应以template<>打头，并通过名称来指出类型。
• 具体化优先于常规模板，而非模板函数优先于具体化和常规模板。

#include <iostream>
using namespace std;

template<typename T>    
void Swap(T &a, T &b);    

struct job
{
    char name[40];
    double salary;
    int floor;
};

template<>void Swap<job>(job &j1, job &j2);
void show(job &j);

int main()
{
    cout.precision(2);      //指定显示多少位小数（假定处于定点模式下）：看前面有没有cout<<fixed，如果没有的话, 是代表2位有效数字, 不是2位小数
    cout.setf(ios::fixed, ios::floatfield);      //ios::fixed设置为定点输出格式，floatfield设置输出时按浮点格式，小数点后有6位数字
    int i = 10, j = 20;
    cout << "i,j= " << i << "," << j << endl;
    Swap(i, j);
    cout << "Now i,j= " << i << "," << j << endl;

    job sue = { "S Y", 73000.60, 7 };
    job sid = { "S T", 78060.72, 9 };
    cout << "Before job swapping: " << endl;
    show(sue);
    show(sid);
    Swap(sue, sid);
    cout << "After job swapping: " << endl;
    show(sue);
    show(sid);
    system("pause");
    return 0;
}

//模板：交换a、b值
template <typename T>
void Swap(T &a, T &b) {
    T temp = a;
    a = b;
    b = temp;
}

//显示具体化：交换结构体内部成员值
template<>void Swap<job>(job &j1, job &j2)
{
    double t1;
    int t2;
    t1 = j1.salary;
    j1.salary = j2.salary;
    j2.salary = t1;

    t2 = j1.floor;
    j1.floor = j2.floor;
    j2.floor = t2;
}

void show(job &j)     //引用
{
    cout << j.name << ":$" << j.salary << " on floor " << j.floor << endl;
}

 8.5.4 实例化和具体化

隐式实例化

显示实例化

显示具体化

8.5.5 编译器选择使用哪个函数版本

重载解析：对于函数重载、函数模板和函数模板重载，C++需要一个定义良好的策略，来决定为函数调用使用哪一个函数定义，尤其是有多个参数时。

#include <iostream>
using namespace std;

template<typename T>       //template A
void showarray(T arr[], int n);    

template<typename T>       //template B
void showarray(T *arr[], int n);

struct debts
{
    char name[50];
    double amount;
};

int main()
{
    int things[6] = { 13,31,103,301,310,130 };
    struct debts mr_E[3]=
    {
        {"I W",2400.0},
        {"U F",1300.0},
        {"I S",1800.0}
    };
    double *pd[3];         //指针数组
    for (int i = 0; i < 3; i++)
    {
        pd[i] = &mr_E[i].amount;
    }
    cout << "Listen:" << endl;
    showarray(things, 6);
    cout << "Listen debts:" << endl;
    showarray(pd, 3);

    system("pause");
    return 0;
}

template<typename T>       //template A
void showarray(T arr[], int n)
{
    cout << "template A" << endl;
    for (int i = 0; i < n; i++)
        cout << arr[i] << ' ';
    cout << endl;
}

template<typename T>       //template B
void showarray(T *arr[], int n)
{
    cout << "template B" << endl;
    for (int i = 0; i < n; i++)
        cout << *arr[i] << ' ';
    cout << endl;
}

 创建自定义选择

#include <iostream>
using namespace std;

//返回小值
template<class T>
T lesser(T a, T b)
{
    cout << "B";
    return a < b ? a : b;
}

//先取绝对值，再返回绝对值中的小值
int lesser(int a, int b)
{
    cout << "A";
    a = a < 0 ? -a : a;
    b = b < 0 ? -b : b;
    return a < b ? a : b;
}

int main()
{
    int m = 20;
    int n = -30;
    double x = 15.5;
    double y = 25.9;
    cout << lesser(m, n) << endl;    //调用函数
    cout << lesser(x, y) << endl;    //调用模板函数
    cout << lesser<>(m, n) << endl;   //<>表示调用模板函数
    cout << lesser<int>(x, y) << endl;   //<int>表示显示实例化，强转x，y的值

    system("pause");
    return 0;
}