《c++程序设计原理与实践》第8章——函数相关的技术细节

声明和定义

为命名实体(如变量、函数)指定一个类型的语句称为声明
int a=7;                  //int型变量
const double cd=8.7;      //双精度浮点变量
double sqrt(double);      //函数声明,参数为double型,返回值为double型
vector<int>v;             //int vector 的变量

C++程序中的名字都必须先声明后使用
一般地,对于在“其他地方”定义的有用的功能,可以在头文件中为其定义接口。大致来说,一个声明定义了一些功能的使用方式,也就是,定义了函数、变量或类的接口

如果一个声明(还)给出了声明的实体的完整描述的话,我们称之为定义

下面是一个定义的例子

int a=7;
vector<int>v;
double sqrt(double d){/*...*/}

每个定义同时也是一个声明,但某些声明不是定义。下面列出一些不是定义的声明,每个声明都需要在代码的其他位置给出相应的定义。

double sqrt(double);   //此处没有函数体
extern int a;          //extern 加上没有初始化意味着未定义

一个定义明确指明了一个名字代表什么。特别地,一个变量定义会为该变量分配存储空间。因此,不能重复定义某个名字。与此相对,一个非定义声明仅仅告诉你如何使用一个名字,它只是一个接口,不会为变量分配存储空间或为函数指定函数体。因此,可以声明一个名字任意多次,只要一致即可。

double sqrt(double);                //声明
double sqrt(double d){/*...*/}     //定义
double sqrt(double);               //sqrt的另一个声明
int sqrt(double);                  //错误:sqrt不一致的声明

声明和定义之间的区别使我们可以将一个程序分为很多部分,分开编译。声明功能使程序的每个部分都能保有程序其他部分的一个视图,而不必关心其他部分中的定义。所有声明必须一致,而整个程序中实体的命名也应一致。

初始化

常量声明的语法与变量声明一样,差别在于类型之前多了一个关键词const,而且必须进行初始化;
对变量也进行初始化通常是个好主意,未初始化的变量会导致隐蔽的错误;
我们倾向于使用{}初始化语法。这是最一般的语法,而且它很明显地表明在进行初始化。对于非常简单的初始化,有时候出于旧有习惯使用=语法;为了指定一个vector的元素的个数,要使用()语法。除此之外,我们最好都使用{}语法来初始化。
通常不对string、vector等对象进行初始化,是因为我们定义string类型和vector类型时定义了默认初始化机制,如果代码中不显示进行初始化,这两种对象就会被用一个默认值进行初始化。vector的初始值为空(不包含任何元素),string的值为空串(“”)。保证默认初始化的机制称为默认构造函数
C++不允许我们对于内置类型设置默认初始化功能。全局变量会被默认初始化为0,但我们应该尽量少用全局变量。而最常使用的变量————局部变量和类成员————是不会被初始化的,除非我们自己对其进行初始化(或提供一个默认构造函数)。

头文件

一个头部是一些声明的集合,一般定义于一个文件,因此也称为头文件。由于#include的处理逻辑上在编译器任何其他动作之前进行,因此被称为预处理。为了方便一致性检查,我们在使用声明的源文件和给出定义的源文件中都包含头文件。

函数的调用和返回

声明参数和返回类型

一个函数声明由一个返回值后跟函数名,再接一个形式参数 列表构成。如果不希望一个函数接受参数,则可以省略形参。如果不希望函数返回一个结果,可将其设置为void。在函数声明和定义中,可以为参数命名也可以不命名。

返回一个值

我们可以用return语句从函数返回一个值,返回值可以看作初始化的另一种形式,并且要切实保证对于函数的每种执行路径都有一条return语句或者一个error()。在一个不返回值的函数中,我们可以调用无值的return语句从函数返回调用者。

void print_until_s(vector<string>v,string quit)
{
    for(int s:v)
    {   
        if(s==quit) 
            return;
        cout<<s<<endl;
    }
}

传值

向函数传递参数最简单的方式是,将参数的值拷贝一份交给函数。传值方式非常直接,其代价就是复制值的开销。不可以修改参数的值。

传常量引用

当拷贝代价非常高,又不想改变参数的值时,可以采用传常量引用的方式。

void print(const vector<double>& v)
{
    cout<<"{";
    for(int i=0;i<v.size();++i)
    {
        cout<<v[i];
        if(i!=v.size()-1)
            cout<<",";
    }
    cout<<"}"<<endl;
}

符号&表示“引用”,而此处的const用来阻止print()无意中修改其参数。不需要拷贝,只读,可以提升效率。

传引用

先探讨一下引用。引用允许用户为一个对象声明一个新的名字。例如,int&是一个整型对象的引用,因此,我们可写出如下的代码。

int i=7;
int &r=i;            //r是i的引用
i=9;                 
r=10;                //i变为10
cout<<i<<' '<<r;     //输出:10 10

也就是说,任何对r的使用实际上使用的是i。
引用的一个用途是作为简写形式。例如,我们可能用得到如下的二维vector
vector<vector<double>>v;
我们需要多次使用某个vector元素v [f(x)] [g(x)]。v [f(x)] [g(x)]是一个复杂的表达式。如果我们只是需要这个元素的值,那么可以声明下面这个变量
double val=v[f(x)][g(x)];
然后多次使用val即可。但如果我们既要从v [f(x)] [g(x)]读取值,又要向它写入值呢?这时,引用就派上用场了:
double &val=v[f(x)][g(x)];
现在,通过var,我们既可以从vf(x)读,也可以向它写。引用这一重要特性,既可以方便地作为某个对象地简写形式的特性,是引用能作为一种有用的参数传递方式的原因。例如:

int f(int& x)
{
    x=x+1;
    return x;
}

int main()
{
    int xx=0;
    cout<<f(xx)<<endl;     //输出:1
    cout<<xx<<endl;        //输出:1;f()改变了xx的值
    return 0;
}

传值与传引用的对比

void f(int a,int& r,const int& cr)
{
    ++a;      //改变局部变量a
    ++r;      //改变r指向的对象
    ++cr;     //错误:cr是常量引用
}
void g(int a,int& r,const int& cr)
{
    ++a;      //改变局部变量a
    ++r;      //改变r指向的对象
    int x=cr;     //错误:cr是常量引用
}

int main()
{
    int x=0;
    int y=0;
    int z=0;
    g(x,y,z);     //x==0;y==1;z==0
    g(1,2,3);     //错误:引用参数r需要指向一个变量
    g(1,y,3);     //正确:因为cr是常量引用,可以传递一个字面常量
}

我们的基本原则是:
1、使用传值方式传递非常小的对象。
2、使用传常量引用方式传递你不需要修改的大对象。
3、让函数返回一个值,而不是修改通过引用参数传递来的对象。
4、只有迫不得已时才使用传引用方式。
第三条规则表达的是,当你想用函数改变一个变量的值时,实际上你还有另一种选择。考虑如下代码:

int incr1(int a)    {return a+1;}   //返回新的值作为结果
void incr2(int& a)  {++a;}          //通过传引用修改对象

int main()
{
    int x=7;
    x=incr1(x);                     //意义非常明显
    incr2(x);                       //相当晦涩难懂
}

实现函数调用

当一个函数被调用时,编译器分配一个数据结构,保存所有参数和局部变量的拷贝。这样的数据结构称为函数活动记录。每当我们调用函数时,活动记录栈————通常就称为栈 生长出一个记录。反过来,当函数返回时,其记录就不再有用。

constexpr函数

告诉编译器 [我认为我是编译器常量], 让编译器在需要编译器常量的语义处 [核实我说的是不是真的]。一个constexpr函数若给定常量表达式(表达式由常量组成)作为参数,则函数计算将在编译时完成。例如:

constexpr double xscale=10;            //缩放分子
constexpr double yscale=0.8;   

constexpr Point scale(Point p)  {  return {xscale*p.x,yscale*p.y}; };

void user(Point p1)
{
    Point p2(10,10);
    
    Point p3=scale(p1);             //正确:p3=={100,8};进行运行时计算
    Point p4=scale(p2);             //p4=={100,8}
    
    constexpr Point p5=scale(p1);   //错误:scale(p1)不是常量表达式
    constexpr Point p6=scale(p2);   //p6=={100,8}
    //...
}

计算顺序

全局初始化

程序员没有有效的方法获知程序的哪一部分读或写了一个全局变量,并且,在不同的编译单元中的全局变量的初始化顺序是不确定的。例如,一个用于商务事务的函数库需要一个Date类型的对象,我们想初始化这个对象:
const Date default_date(1970,1,1);
我们如何知道default_date在初始化之前从未被使用过呢?原则上我们不可能知道,因此我们不应该写出这样的代码。一种常用的技术是编写一个函数,返回我们需要的初值。例如:

const Date default_date()       //返回默认日期
{
    return Date(1970,1,1);
}

每当我们调用default_date()函数,它都会为我们创建一个Date对象。一般情况下,这种技术已经足够好,但如果需要频繁调用default_date(),而且构造Date对象代价较高的话,我们更倾向于只构造它一次。可以这样做:

const Date& default_date()       //返回默认日期
{
    static const Date dd(1970,1,1);
    return dd;
}

一个静态的局部变量只有在函数首次调用时才被初始化(被创建)。注意,这里我们返回一个引用,因此消除了不必要的对象拷贝。特别地,我们返回了一个常量引用,可以防止调用者无意中修改对象的值。

名字空间

无须定义一个类型就能将类、函数、数据和类型组织成一个可识别的命名实体的声明分组功能就是C++机制中的名字空间 。

namespace TextLib{
    class Text{/*...*/};
    class Glyph{/*...*/};
    class Line{/*...*/};
    //...
}

由一个名字空间的名字(或一个类名)和一个成员名组合成的名字称为全限定名 。例如,TextLib::Text

using声明和using指令

#include <iostream>
#include <string>

int main()
{
    std::string name;
    std::cout<<"please enter your first name\n";
    std::cin>>name;
    std::cout<<"Hello,"<<name<<endl;
}

可以使用using声明简化程序

using std::string;      //string即为std::string
using std::cout;        //cout即为std::cout

还可以用一种更强的“简称”用来引用名字空间中的名字:“如果你在本作用域中没有发现某个名字的声明,那么就在std中寻找它。”使用using指令可以达到这个目的
using namespace std;
一个一般性的原则是,除非是std这种在某个应用领域中大家已经非常熟悉的名字空间,否则最好不要使用using指令。因为过度使用using指令会使我们记不清每个名字来自哪里,结果陷入名字冲突中。显示使用全限定名或者使用using声明就不存在这个问题。

评论

暂无评论