《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。
引用的一个用途是作为简写形式。例如,我们可能用得到如下的二维vectorvector<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声明就不存在这个问题。

评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论