presentation: width: 1024 height: 768 #theme: blood.css theme: white.css

面向对象编程基础¶

本课程入选教育部产学合作协同育人项目课程主页:http://cpp.njuer.org 课程老师:陈明 http://cv.mchen.org

ppt和代码下载地址
git clone https://gitee.com/cpp-njuer-org/book

第6章¶

函数¶

函数基础
参数传递
返回类型和return语句
函数重载
特殊用途语言途径
函数匹配
函数指针

函数基础¶

函数定义：包括返回类型、函数名字和0个或者多个形参（parameter）组成的列表和函数体。
- 形参以逗号隔开，形参列表位于一堆圆括号之内
- 函数执行的操作在语句块中说明，该语句块成为函数体。

调用运算符来执行函数：
- 调用运算符的形式是一对圆括号 ()，作用于一个表达式，该表达式是函数或者指向函数的指针。
- 圆括号内是用逗号隔开的实参（argument）列表。实参初始化形参。
- 调用表达式类型是函数返回类型。

编写函数¶

// factorial of val is val * (val - 1) *  (val - 2) . . . *  1
int fact(int val)
{
    int ret = 1; // local variable to hold the result as we calculate it
    while (val > 1) 
        ret *= val--;  // assign ret * val to ret and decrement val
    return ret;        // return the result
}

调用函数¶

int main(){
    int j=fact(5);
    cout<<"5! is "<<j<<endl;
    return 0;
}

//fact.cpp
#include<iostream>
using std::cout;using std::endl;
// factorial of val is val * (val - 1) *  (val - 2) . . . * 1
int fact(int val)
{
    int ret = 1; // local variable to hold the result as we calculate it
    while (val > 1)
        ret *= val--;  // assign ret * val to ret and decrement val
    return ret;        // return the result
}

int main(){
    int j=fact(5);
    cout<<"5! is "<<j<<endl;
    return 0;
}
//5! is 120

函数调用过程¶

实参初始化函数的形参
控制器转移给被调用函数
- 主调函数（calling function）的执行被中断。
- 被调函数（called function）开始执行。

执行函数第一步隐式定义初始化形参

return语句结束函数执行过程

返回return语句的值（如果有的话）

控制权从被调函数转移回主调函数

//调用fact 函数效用等价于
    int val = 5;
    int ret = 1;
    while (val > 1)
        ret *= val--;
    int j=ret;

形参与实参¶

形参和实参的个数和类型必须匹配上。

fact("hello");  // 错误 实参类型不正确
fact();         // 错误 实参参数不足
fact(42,10,0);  // 错误 实参参数过多
fact(3.14)      // 正确 能转换成int类型,等价于fact(3)

函数的形参列表¶

形参列表可为空，不能省略

void f1(){/* ...*/}     //隐式定义空形参列表
void f2(void){/* ...*/} //显示定义空形参列表

形参用逗号隔开，必须写出类型

int f3(int v1,v2){/* ...*/}     //错误
int f4(int v1, int v2){/* ...*/} //正确

函数返回类型¶

void返回类型,表示函数不返回任何值。
函数的返回类型不能是数组类型或者函数类型，但可以是指向数组或者函数的指针。

练习¶

实参和形参的区别的什么？
实参是函数调用的实际值，是形参的初始值。

练习¶

请指出下列函数哪个有错误，为什么？应该如何修改这些错误呢？
(a) int f() {
         string s;
         // ...
         return s;
   }
(b) f2(int i) { /* ... */ }
(c) int calc(int v1, int v1) { /* ... */ }
(d) double square (double x)  return x * x; 

应该改为下面这样：
(a) string f() {
         string s;
         // ...
         return s;
   }
(b) void f2(int i) { /* ... */ }
(c) int calc(int v1, int v2) { /* ... */ return ; }
(d) double square (double x) { return x * x; }

练习¶

编写你自己的fact函数，上机检查是否正确。阶乘。
//fact2.cpp
#include <iostream>
int fact(int i){
    try{
        if(i<0){
            throw std::runtime_error("Input a wrong number");
        }
    }
    catch(std::runtime_error err){
        std::cout << err.what() << std::endl;
    }
    return i > 1 ? i * fact( i - 1 ) : 1;
}
int main(){
    //std::boolalpha,可以输出 "true"或者 "false"
    std::cout << std::boolalpha << (120 == fact(5)) << std::endl;
    return 0;
}

练习¶

编写一个与用户交互的函数，要求用户输入一个数字，计算生成该数字的阶乘。
在main函数中调用该函数。

#include <iostream>
#include <string>
int fact(int i){
    return i > 1 ? i * fact(i - 1) : 1;
}
void interactive_fact(){
    std::string const prompt = "Enter a number within [1, 13) :\n";
    std::string const out_of_range = "Out of range, please try again.\n";
    for (int i; std::cout << prompt, std::cin >> i; ) {
        if (i < 1 || i > 12){
            std::cout << out_of_range; 
            continue;
        }
        std::cout << fact(i) << std::endl;
    }
}

int main(){
    interactive_fact();
    return 0;
}

练习¶

编写一个函数输出其实参的绝对值。

#include <iostream>

int abs(int i)
{
   return i > 0 ? i : -i;
}

int main()
{
   std::cout << abs(-5) << std::endl;
   return 0;
}

局部对象¶

名字有作用域，对象有生命周期
- 名字的作用域是程序文本的一部分，名字在其中可见。
- 对象的生命周期是程序执行过程中该对象存在的一段时间。
局部变量（local variable）：形参和函数体内部定义的变量统称为局部变量。它对函数而言是局部的，对函数外部而言是隐藏的。
在所有函数体之外定义的对象存在于整个执行过程。

自动对象¶

只存在于块执行期间的对象。当块的执行结束后，它的值就变成未定义的了。
形参是一种自动对象。
- 函数开始，形参申请存储空间
- 函数终止，形参销毁。
实参初始化形参对应的自动对象
- 初始值初始化
- 默认初始化。内置类型的未初始化局部变量将产生未定义的值。

局部静态对象¶

static类型的局部变量，生命周期贯穿函数调用前后。

//局部静态变量在程序的执行路径第一次经过对象定义语句时初始化，
//并且直到程序终止时才被销毁。
//count_calls.cpp
#include <cstddef>
using std::size_t;
#include <iostream>
using std::cout; using std::endl;
size_t count_calls(){
    static size_t ctr = 0;  // value will persist across calls
    return ++ctr;
}
int main(){
    for (size_t i = 0; i != 10; ++i)
        cout << count_calls() << endl;
    return 0;
}

练习¶

说明形参、局部变量以及局部静态变量的区别。编写一个函数，同时达到这三种形式。

形参定义在函数形参列表里面；局部变量定义在代码块里面；
局部静态变量在程序的执行路径第一次经过对象定义语句时初始化，
并且直到程序终止时才被销毁。
// 例子
int count_add(int n)       // n是形参
{
    static int ctr = 0;    // ctr 是局部静态变量
    ctr += n;
    return ctr;
}
int main()
{
    for (int i = 0; i != 10; ++i)  // i 是局部变量
      cout << count_add(i) << endl;

    return 0;
}

练习¶

编写一个函数，当它第一次被调用时返回0，以后每次被调用返回值加1。
int generate()
{
    static int ctr = 0;
    return ctr++;
}

函数声明¶

函数的名字必须在使用前声明。
函数的声明和定义唯一的区别是声明无需函数体，用一个分号替代。
函数三要素：返回类型、函数名、形参类型描述函数接口
函数声明主要用于描述函数的接口，也称函数原型。

在头文件中进行函数声明¶

建议变量、函数在头文件中声明,在源文件中定义。
含有函数声明的头文件应该被包含到定义函数的源文件中。

练习¶

编写一个名为Chapter6.h 的头文件，令其包含练习中的函数声明。
//Chapter6.h
#ifndef chapter6_def
#define chapter6_def
int fact(int val);
int func();
double abs1(double i);
#endif

分离式编译¶

- CC 是c编译器的名字，如gcc .CXX是c++编译器的名字，如g++
export CC=gcc CXX=g++
$CXX test.cpp -o a.out

- .cc是扩展名，表示c++源文件

CC a.cc b.cc直接编译生成可执行文件a.out；
CC a.cc b.cc -o main 直接编译生成可执行文件main；
CC -c a.cc b.cc编译生成对象代码a.o b.o； 
CC a.o b.o编译生成可执行文件a.out
CC a.o b.o -o main 编译生成可执行文件main。

练习¶

编写你自己的fact.cc 和factMain.cc ，这两个文件都应该包含上一小节的练习中
编写的 Chapter6.h 头文件。
通过这些文件，理解你的编译器是如何支持分离式编译的。

//fact.cc：
#include "Chapter6.h"
#include <iostream>
int fact(int val){
    if (val == 0 || val == 1) return 1;
    else return val * fact(val-1);
}
int func(){
    int n, ret = 1;
    std::cout << "input a number: ";
    std::cin >> n;
    while (n > 1) ret *= n--;
    return ret;
}

double abs1(double i)
{
    return i>0?i:-i;
}

//Chapter6.h
#ifndef chapter6_def
#define chapter6_def
int fact(int val);
int func();
double abs1(double i);
#endif


//factMain.cc：
#include "Chapter6.h"
#include <iostream>
int main(){
    std::cout << "5! is " << fact(5) << std::endl;
    std::cout << func() << std::endl;
    std::cout << abs1(-12.0) << std::endl;
}

//编译： g++ factMain.cc fact.cc -o a.out
或者写个makefile后,敲命令make
//makefile
target: fact.o factMain.o
    g++ fact.o factMain.o -o a.out

fact.o: fact.cc
factMain.o: factMain.cc 

clean:
    rm ./fact.o factMain.o a.out

参数传递¶

形参初始化的机理和变量初始化一样。
引用传递（passed by reference）：又称传引用调用（called by reference），指形参是引用类型，引用形参是它对应的实参的别名。
值传递（passed by value）：又称传值调用（called by value），指实参的值是通过拷贝传递给形参。

传值参数¶

当初始化一个非引用类型的变量时，初始值被拷贝给变量。
函数对形参做的所有操作都不会影响实参。
指针形参：常用在C中，C++建议使用引用类型的形参代替指针。

练习¶

编写一个函数，使用指针形参交换两个整数的值。
在代码中调用该函数并输出交换后的结果，以此验证函数的正确性。
//swap.cpp
#include <iostream>
#include <string>
void swap(int* lhs, int* rhs){
    int tmp;
    tmp = *lhs;
    *lhs = *rhs;
    *rhs = tmp;
}
int main(){
    for (int lft, rht; 
        std::cout << "Please Enter:\n", std::cin >> lft >> rht;){
        swap(&lft, &rht);
        std::cout << lft << " " << rht << std::endl;
    }
    return 0;
}

传引用参数¶

通过使用引用形参，允许函数改变一个或多个实参的值。
引用形参直接关联到绑定的对象，而非对象的副本。
使用引用形参可以用于返回额外的信息。
经常用引用形参来避免不必要的复制。
如果无需改变引用形参的值，最好将其声明为常量引用。

//使用引用形参可以返回额外的信息
//返回s中c第一次出现的位置索引，occurs负责统计次数
//find_char.cpp
#include<iostream>
#include<string>
using namespace std;
string::size_type find_char(const string &s,char c,
        string::size_type &occurs){
    auto ret=s.size();
    occurs=0;
    for(decltype(ret)i=0;i!=s.size();++i){
        if(s[i]==c){
            if(ret==s.size())
                ret=i;
            ++occurs;
        }
    }
    return ret;
}

int main(){
    string s = "bbasdfa";
    string::size_type ctr=0;
    auto index  = find_char(s,'a',ctr);
    cout<<index<<" "<<ctr<<endl;// 2 2
}

练习¶

编写并验证你自己的reset函数，使其作用于引用类型的参数。注：reset即置0。

#include <iostream>
void reset(int &i)
{
    i = 0;
}
int main()
{
    int i = 42;
    reset(i);
    std::cout << i  << std::endl;
    return 0;
}

练习¶

改写练习中的程序，引用而非指针交换两个整数的值。你觉得哪种方法更易于使用呢？为什么？
#include <iostream>
#include <string>
void swap(int& lhs, int& rhs){
    int temp = lhs;
    lhs = rhs;
    rhs = temp;
}
int main(){
    for (int left, right; std::cout << "Please Enter:\n", 
                                    std::cin >> left >> right; ){
        swap(left, right);
        std::cout << left << " " << right << std::endl;
    }
    return 0;
}
//很明显引用更好用。

练习¶

假设T是某种类型的名字，说明以下两个函数声明的区别：
一个是void f(T), 另一个是void f(&T)。

void f(T)的参数通过值传递，
在函数中T是实参的副本, 改变T不会影响到原来的实参。
void f(&T)的参数通过引用传递，
在函数中的T是实参的引用，T的改变也就是实参的改变。

练习¶

举一个形参应该是引用类型的例子，再举一个形参不能是引用类型的例子。
例如交换两个整数的函数，形参应该是引用
void swap(int& lhs, int& rhs){
    int temp = lhs;
    lhs = rhs;
    rhs = temp;
}
当实参的值是右值时，形参不能为引用类型
int add(int a, int b){
    return a + b;
}
int main(){
    int i = add(1,2);
    return 0;
}

练习¶

说明find_char函数中的三个形参为什么是现在的类型，
特别说明为什么s是常量引用而occurs是普通引用？
为什么s和occurs是引用类型而c不是？
如果令s是普通引用会发生什么情况？
如果令occurs是常量引用会发生什么情况？

- 因为字符串可能很长，因此使用引用避免拷贝；
- 而在函数中我们不希望改变s的内容，所以令s为常量。
- occurs是要传到函数外部的变量，所以使用引用，occurs的值会改变，
    所以是普通引用。
- 因为我们只需要c的值，这个实参可能是右值(右值实参无法用于引用形参)，
    所以c不能用引用类型。
- 如果s是普通引用，也可能会意外改变原来字符串的内容。
- occurs如果是常量引用，那么意味着不能改变它的值，那也就失去意义了。

const形参和实参¶

形参的顶层const被忽略。

void func(const int i);//调用时既可以传入const int也可以传入int。

void fcn(const int i);
void fcn(int i);//错误，重复定义了fcn（int）//顶层const被忽略

指针或引用形参与const¶

int i=42;
const int *cp=&i;   //正确，*cp不能改
const int &r=i;     //正确，r不能改
const int &r2=42;   //正确
int *p=cp;          //错误，类型不匹配
int &r3=r;          //错误，类型不匹配
int &r4=42;         //错误，不能用字面值初始化一个非常量引用

指针或引用形参与const¶

void reset(int *ip){*ip=0;ip=0;}
void reset(int &ip){ip=0;}
//应用到参数传递
int i=0;
const int ci =i;
string::size_type ctr=0;
reset(&i);          //调用形参类型是int*
reset(&ci);         //错误，不能用const int 对象指针初始化int *
reset(i);           //调用形参类型是int&
reset(ci);          //错误，不能把普通引用绑定到const 对象ci
reset(42);          //错误，不能把普通引用绑定到字面值
reset(ctr);         //错误，类型不匹配，ctr无符号数
find_char("hello",'o',ctr);//正确，第一个形参对常量的引用

尽量使用常量引用
- 实参类型不受限
- 不会修改实参

练习¶

下面的这个函数虽然合法，但是不算特别有用。指出它的局限性并设法改善。
bool is_empty(string& s) { return s.empty(); }

局限性在于常量字符串和字符串字面值无法作为该函数的实参，
如果下面这样调用是非法的：
const string str;
bool flag = is_empty(str); //非法
bool flag = is_empty("hello"); //非法
所以要将这个函数的形参定义为常量引用：
bool is_empty(const string& s) { return s.empty(); }

练习¶

编写一个函数，判断string对象中是否含有大写字母。
编写另一个函数，把string对象全部改写成小写形式。
在这两个函数中你使用的形参类型相同吗？为什么？


两个函数的形参不一样。第一个函数使用常量引用，第二个函数使用普通引用。

练习¶

为下面的函数编写函数声明，从给定的名字中推测函数具备的功能。
- (a) 名为compare的函数，返回布尔值，两个参数都是matrix类的引用。
- (b) 名为change_val的函数，返回vector的迭代器，
    有两个参数：一个是int，另一个是vector的迭代器。

(a) bool compare(matrix &m1, matrix &m2);
(b) vector<int>::iterator change_val(int, vector<int>::iterator);

练习¶

假定有如下声明，判断哪个调用合法、哪个调用不合法。对于不合法的函数调用，说明原因。
double calc(double);
int count(const string &, char);
int sum(vector<int>::iterator, vector<int>::iterator, int);
vector<int> vec(10);
(a) calc(23.4, 55.1);
(b) count("abcda",'a');
(c) calc(66);
(d) sum(vec.begin(), vec.end(), 3.8);

- (a) 不合法。calc只有一个参数。
- (b) 合法。
- (c) 合法。
- (d) 合法。

练习¶

引用形参什么时候应该是常量引用？如果形参应该是常量引用，
而我们将其设为了普通引用，会发生什么情况？

应该尽量将引用形参设为常量引用，除非有明确的目的是为了改变这个引用变量。
如果形参应该是常量引用，而我们将其设为了普通引用，
那么常量实参将无法作用于普通引用形参。

数组形参¶

当我们为函数传递一个数组时，实际上传递的是指向数组首元素的指针。

要注意数组的实际长度，不能越界。

//三个函数等价.形参const int*
void print(const int*);
void print(const int[]);
void print(const int[10]);

使用标记指定数组长度('\0'，int数组无效)
使用标准库规范begin end

显式传递一个表示数组大小的形参

void print(const char *p);

int j[2]={0,1};
print(begin(j),end(j));

void print(const int a[],size_t size);
print(j,end(j)-begin(j));

//print.cpp
#include <iterator>
using std::begin; using std::end;
#include <cstddef>
using std::size_t;
#include <iostream>
using std::cout; using std::endl;
// const int ia[] is equivalent to const int* ia
// size is passed explicitly and used to control access to elements of ia
void print(const int ia[], size_t size){
    for (size_t i = 0; i != size; ++i) {
        cout << ia[i] << endl;
    }
}
int main(){
    int j[] = { 0, 1 };  // int array of size 2
    print(j, end(j) - begin(j));
    return 0;
}

数组引用形参¶

void print(int (&arr)[10]){
    for(auto elem:arr)
        cout<<elem<<endl;
}


//&arr两端的括号不可少
f(int &arr[10])//错误 arr声明成引用的数组
f(int (&arr)[10])//正确arr是具有10个整数的整型数组的引用

//传递多维数组

//matrix 指向数组的首元素，该数组的元素是有10个整数构成的数组
void print(int (*matrix)[10], int rowSize){/*...*/}
//等价于
void print(int matrix[][10],int rowSize){/*...*/}



//括号不可少
int *matrix[10];//10个指针构成的数组
int (*matrix)[10];//指向含有10个整数的数组的指针

练习¶

编写一个函数，令其接受两个参数：一个是int型的数，另一个是int指针。
函数比较int的值和指针所指的值，返回较大的那个。
在该函数中指针的类型应该是什么？

#include <iostream>
using std::cout;
int larger_one(const int i, const int *const p){
    return (i > *p) ? i : *p;
}
int main(){
    int i = 6;
    cout << larger_one(7, &i);
    return 0;
}
//应该是const int *类型。

练习¶

编写一个函数，令其交换两个int指针。

#include <iostream>
#include <string>
void swap(int*& lft, int*& rht){
    auto tmp = lft;
    lft = rht;
    rht = tmp;
}
int main(){
    int i = 42, j = 99;
    auto lft = &i;
    auto rht = &j;
    swap(lft, rht);
    std::cout << *lft << " " << *rht << std::endl;
    return 0;
}

练习¶

参考本节介绍的几个print函数，根据理解编写你自己的版本。
依次调用每个函数使其输入下面定义的i和j:
int i = 0, j[2] = { 0, 1 };
#include <iostream>
using std::cout; using std::endl; using std::begin; using std::end;
void print(const int *pi){
    if(pi)   cout << *pi << endl;
}
void print(const char *p){
    if (p)    while (*p) cout << *p++;
    cout << endl;
}
void print(const int *beg, const int *end){
    while (beg != end)
        cout << *beg++ << endl;
}
void print(const int ia[], size_t size){
    for (size_t i = 0; i != size; ++i) {
        cout << ia[i] << endl;
    }
}

练习¶

void print(int (&arr)[2]){
    for (auto i : arr)
        cout << i << endl;
}
int main()
{
    int i = 0, j[2] = { 0, 1 };
    char ch[5] = "asdf";

    print(ch);
    print(begin(j), end(j));
    print(&i);
    print(j, end(j)-begin(j));
    print(j);

    return 0;
}

练习¶

描述下面这个函数的行为。如果代码中存在问题，请指出并改正。

void print(const int ia[10])
{
    for (size_t i = 0; i != 10; ++i)
        cout << ia[i] << endl;
}

当数组作为实参的时候，会被自动转换为指向首元素的指针。
因此函数形参接受的是一个指针。
如果要让这个代码成功运行(不更改也可以运行），可以将形参改为数组的引用。
void print(const int (&ia)[10])
{
    for (size_t i = 0; i != 10; ++i)
        cout << ia[i] << endl;
}

main处理命令行选项¶

第一个形参代表参数的个数；第二个形参是参数C风格字符串数组。

int main(int argc, char *argv[]){...}
argv[0]保存程序的名字 而非用户输入

练习¶

编写一个main函数，令其接受两个实参。把实参的内容连接成一个string对象并输出。
编写一个程序，使其接受本节所示的选项；输出传递给main函数的实参内容。

#include <iostream>
#include <string>
int main(int argc, char **argv)
{
    std::string str;
    for (int i = 1; i != argc; ++i)
        str += std::string(argv[i]) + " ";

    std::cout << str << std::endl;
    return 0;
}

含有可变形参的函数¶

initializer_list提供的操作（C++11）

 initializer_list<T> lst;           //默认初始化；T类型元素的空列表 
 initializer_list<T> lst{a,b,c...}; //lst的元素数量和初始值一样多；
                    //lst的元素是对应初始值的副本；列表中的元素是const。 
 lst2(lst)                          //拷贝或赋值一个initializer_list对象
                    //不会拷贝列表中的元素；拷贝后，原始列表和副本共享元素。 
 lst2 = lst                         //同上 
 lst.size()                         //列表中的元素数量 
 lst.begin()                        //返回指向lst中首元素的指针 
 lst.end()                          //返回指向lst中微元素下一位置的指针

initializer_list 使用：

void err_msg(ErrCode e, initializer_list<string> il){
    cout << e.msg << endl;
    for (auto bed = il.begin(); beg != il.end(); ++ beg)
        cout << *beg << " ";
    cout << endl;
}

err_msg(ErrCode(0), {"functionX", "okay"});

所有实参类型相同，可以使用 initializer_list的标准库类型。
省略符形参： ...，便于C++访问某些C代码，这些C代码使用了 varargs的C标准功能。

练习¶

编写一个函数，它的参数是initializer_list类型的对象，函数的功能是计算列表中所有元素的和。

#include <iostream>
#include <initializer_list>
int sum(std::initializer_list<int> const& il)
{
    int sum = 0;
    for (auto i : il) sum += i;
    return sum;
}
int main(void)
{
    auto il = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    std::cout << sum(il) << std::endl;

    return 0;
}

练习¶

在error_msg函数的第二个版本中包含ErrCode类型的参数，
其中循环内的elem是什么类型？
for(const auto &elem:il) cout<<elem<<" ";
elem是const string &类型。

在范围for循环中使用initializer_list对象时，
应该将循环控制变量声明成引用类型吗？为什么？
应该使用常量引用类型。initializer_list对象中的元素都是常量，
我们无法修改initializer_list对象中的元素的值。

返回类型和return语句¶

无返回值函数¶

return语句只用在返回类型是 void的函数中
返回 void的函数不要求非得有 return语句。

有返回值函数¶

return语句的返回值的类型必须和函数的返回类型相同，或者能够隐式地转换成函数的返回类型。
值的返回：返回的值用于初始化调用点的一个临时量，该临时量就是函数调用的结果。
不要返回局部对象的引用或指针。

有返回值函数¶

引用返回左值：函数的返回类型决定函数调用是否是左值。调用一个返回引用的函数得到左值；其他返回类型得到右值。
列表初始化返回值：函数可以返回花括号包围的值的列表。（C++11）
主函数main的返回值：如果结尾没有return，编译器将隐式地插入一条返回0的return语句。返回0代表执行成功。

递归¶

函数调用自身，递归函数
- 递归循环
- 终止条件

练习¶

编译str_subrange函数，看看你的编译器是如何处理函数中的错误的。

编译错误信息：
error: return-statement with no value, in function returning ‘bool’ [-fpermissive]

练习¶

什么情况下返回的引用无效？什么情况下返回常量的引用无效？

当返回的引用的对象是局部变量时，返回的引用无效；
当我们希望返回的对象被修改时，返回常量的引用无效。

练习¶

下面的函数合法吗？如果合法，说明其功能；如果不合法，修改其中的错误并解释原因。

int &get(int *array, int index) { return array[index]; }
int main()
{
    int ia[10];
    for (int i = 0; i != 10; ++i)
        get(ia, i) = i;
}

合法。get函数根据索引取得数组中的元素的引用。

练习¶

编写一个递归函数，输出vector对象的内容。
#include <iostream>
#include <vector>
using std::vector; using std::cout;
using Iter = vector<int>::const_iterator;
void print(Iter first, Iter last){
    if (first != last){
        cout << *first << " ";
        print(++first, last);
    }
}
int main()
{
    vector<int> vec{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    print(vec.cbegin(), vec.cend());
    return 0;
}

练习¶

如果factorial函数的停止条件如下所示，将发生什么？
if (val != 0)

如果val为正数，从结果上来说没有区别（多乘了个1）; 
如果val为负数，那么递归永远不会结束。

练习¶

在调用factorial函数时，为什么我们传入的值是val-1而非val--？
如果传入的值是val--，那么将会永远传入相同的值来调用该函数，递归将永远不会结束。

返回数组指针¶

//使用类型别名
typedef int arrT[10];//含有10个整数的数组

using arrT = int[10;]//等价声明
arrT* func() {...}      //返回一个指向含有10个整数的数组的指针

声明一个返回数组指针的函数¶

int arr[10];//数组
int *p1[10];//指针数组
int (*p2)[10]=&arr;//p2指向含有10个整数的数组
//返回数组指针的函数形式如下：
Type (*function (parameter_list))[dimension]

int (*func(int i))[10]
- func(int i)表示func函数的参数是int
- int (*func(int i))可以对函数调用结果解引用
-  (*func(int i))[10]解引用得到大小是10 的数组
- int (*func(int i))[10]数组的元素是int

使用尾置返回类型¶

为简化上述func声明方法

在形参列表后面以一个->开始
//func函数返回一个指针，指向含有10个整数的数组
auto func(int i) -> int(*)[10]
//（C++11）

decltype¶

int odd[]={1,3,5,7,9};
int even[]={0,2,4,6,8};
//返回一个指针，指向含有5个整数的数组
decltype(odd) *arrPtr(int i) {
    return (i%2)?&odd:&even;
}
//decltype 不负责把数组转成对应的指针，
//所以decltype结果是数组，返回指针函数声明加*

练习¶

编写一个函数声明，使其返回数组的引用并且该数组包含10个string对象。
不用使用尾置返回类型、decltype或者类型别名。
string (&fun())[10];

练习¶

为上一题的函数再写三个声明，一个使用类型别名，另一个使用尾置返回类型，最后一个使用decltype关键字。
你觉得哪种形式最好？为什么？

typedef string str_arr[10];
str_arr& fun();

auto fun()->string(&)[10];

string s[10];
decltype(s)& fun();

练习¶

修改arrPtr函数，使其返回数组的引用。
decltype(odd)& arrPtr(int i)
{
    return (i % 2) ? odd : even;
}

函数重载¶

重载：如果同一作用域内几个函数名字相同但形参列表不同，我们称之为重载（overload）函数。
main函数不能重载。
定义重载函数
- 不允许两个函数除返回值外其它要素相同。
- 有时形参列表看起来不一样，实际相同(省略形参、别名)

函数重载¶

重载和const形参：
一个有顶层const的形参和没有它的函数无法区分。

相反，是否有某个底层const形参可以区分。

//顶层const不影响传入的对象
Record lookup(Phone* const)和 Record lookup(Phone*)无法区分。
Record lookup(Account*)和 Record lookup(const Account*)可以区分。

const_cast和重载¶

const string& shorterString(const string& s1,const string& s2){
    return s1.size()<s2.size()?s1:s2;
}

string &shorterString(string &s1,string &s2){
    auto &r= shorterString(const_cast<const string&>(s1),
                            const_cast<const string&)(s2));
    return const_cast<string&>(r);
}

调用重载的函数¶

函数匹配是指一个过程，把函数调用和一组重载函数中某一个关联起来，也叫重载确定。
调用重载函数，三种可能结果
- 最佳匹配
- 无匹配
- 二义性调用报错

练习¶

说明在下面的每组声明中第二条语句是何含义。
如果有非法的声明，请指出来。
(a) int calc(int, int);
    int calc(const int, const int);
(b) int get();
    double get();
(c) int *reset(int *);
    double *reset(double *);

- (a) 非法。因为顶层const不影响传入函数的对象，所以第二个声明无法与第一个声明区分开来。
- (b) 非法。对于重载的函数来说，它们应该只有形参的数量和形参的类型不同。返回值与重载无关。
- (c) 合法。

重载和作用域¶

若在内层作用域中声明名字，它将隐藏外层作用域中声明的同名实体，在不同的作用域中无法重载函数名。

string read();
void print(const string&);
void print(double);
void fooBar(int ival){
    bool read=false;
    string s=read();//wrong read是bool
    void print(int);//新作用域
    print("Value:");//wrong 被隐藏print(const string&)
    print(ival);    //正确
    print(3.14);    //print(int)
}

重载和作用域¶

void print(const string&);
void print(double);
void print(int);
void fooBar2(int ival){
    print("Value:");//print(const string&)
    print(ival);    //print(int)
    print(3.14);    //print(double)
}

特殊用途语言特性¶

默认实参¶

// 一旦某个形参被赋予了默认值，那么它之后的形参都必须要有默认值。
typedef string::size_type sz;
string screen(sz ht = 24, sz wid = 80, char backgrnd = ' ');
//使用默认实参调用函数
string window;
window = screen();          //等价于screen(24,80,' ')
window = screen(66);        //等价于screen(66,80,' ')
window = screen(66,256);    //等价于screen(66,256,' ')
window = screen(66,256,'#');//等价于screen(66,256,'#')

window = screen(,,'?');     //错误，只能省略尾部的实参
window = screen('?');       //等价于screen(24,80,'?')
//设计含有默认实参的函数时，尽量让不怎么使用默认值的形参出现在前面

默认实参声明¶

//将函数声明放入头文件，一个函数只声明一次（多次声明同一个函数也合法）
//给定作用域中一个形参只能被赋予一次默认实参

//高度 宽度的形参没有默认值
string screen(sz,sz,char= '');

string screen(sz,sz,char= '*');//错误，重复声明
string screen(sz=24,sz=80,char);//正确 添加默认实参
//通常应该在函数声明中指定默认实参，并将声明放在合适的头文件中

默认实参初始值¶

// wd def 和ht的声明必须出现在函数外
sz wd=80;
char def = ' ';
sz ht();
string screen(sz=ht(),sz=wd,char=def);
string window = screen(); //调用screen(ht(),80,' ')

void f2()
{
    def='*';//改变默认实参的值
    sz wd=100;//隐藏外层定义的wd，但没有改变默认值
    window=screen();//调用screen(ht(),80,'*')
}

练习¶

下面的哪个声明是错误的？为什么？

(a) int ff(int a, int b = 0, int c = 0);
(b) char *init(int ht = 24, int wd, char bckgrnd);    

(a) 正确。
(b) 错误。因为一旦某个形参被赋予了默认值，那么它之后的形参都必须要有默认值。

练习¶

下面的哪个调用是非法的？为什么？哪个调用虽然合法但显然与程序员的初衷不符？为什么？
char *init(int ht, int wd = 80, char bckgrnd = ' ');
(a) init();
(b) init(24,10);
(c) init(14,'*');

- (a) 非法。第一个参数不是默认参数，最少需要一个实参。
- (b) 合法。
- (c) 合法，但与初衷不符。字符*被解释成int传入到了第二个参数。而初衷是要传给第三个参数。

练习¶

给make_plural函数的第二个形参赋予默认实参's', 
利用新版本的函数输出单词success和failure的单数和复数形式。
#include <iostream>
#include <string>
using std::string;
using std::cout;
using std::endl;
string make_plural(size_t ctr, const string& word, 
                        const string& ending = "s"){
    return (ctr > 1) ? word + ending : word;
}
int main(){
    cout << "single: " << make_plural(1, "success", "es") << " "
        << make_plural(1, "failure") << endl;
    cout << "plural : " << make_plural(2, "success", "es") << " "
        << make_plural(2, "failure") << endl;
    return 0;
}

内联函数和constexpr函数¶

把规模较小的操作定义成函数有很多好处
- 阅读理解容易
- 使用函数确保行为统一
- 修改函数更容易
- 可被重复利用，省去重新编写的代价
代价
- 调用函数比求解等价表达式的值慢一些
- 调用函数包含一系列工作：
    - 保存寄存器 返回时恢复。可能要拷贝实参。程序转向新位置执行。

内联（inline）函数¶

inline函数可以避免函数调用的开销，可以让编译器在编译时内联地展开该函数。
inline函数应该在头文件中定义。

inline const string&
shorterString(const string &s1,const string& s2){
    return s1.size()<=s2.size()?s1:s2;
}

cout<<shorterString(s1,s2)<<endl;
//编译过程展开类似下面形式,从而消除函数运行开销
cout<<(s1.size()<s2.size())?s1:s2)<<endll;

//内联说明只是向编译器发出一个请求，编译器可以选择忽略这个请求

constexpr函数¶

- 指能用于常量表达式的函数。
- 函数的返回类型及所有形参类型都要是字面值类型。
constexpr int new_sz() {return 42;}
constexpr int foo = new_sz();//正确 foo是一个常量表达式

//如果arg是常量表达式，则scale(arg)也是常量表达式
constexpr size_t scale(size_t cnt){return new_sz()*cnt;}
int arr[scale(2)];//正确 scale(2)是常量表达式
int i=2;
int a2[scale(i)];//错误 scale(i)不是常量表达式
//constexpr 函数不一定返回常量表达式

//inline函数和constexpr函数通常在头文件中定义。

练习¶

你会把下面的哪个声明和定义放在头文件中？哪个放在源文件中？为什么？
(a) inline bool eq(const BigInt&, const BigInt&) {...}
(b) void putValues(int *arr, int size);

全部都放进头文件。(a) 是内联函数，(b) 是声明。

练习¶

isShorter函数改写成内联函数。

inline bool is_shorter(const string &lft, const string &rht) 
{
    return lft.size() < rht.size();
}

练习¶

回顾在前面的练习中你编写的那些函数，它们应该是内联函数吗？
如果是，将它们改写成内联函数；如果不是，说明原因。

一般来说，内联机制用于优化规模小、流程直接、频繁调用的函数。

练习¶

能把isShorter函数定义成constexpr函数吗？
如果能，将它改写成constxpre函数；如果不能，说明原因。

不能。constexpr函数的返回值类型及所有形参都得是字面值类型。

调试帮助¶

assert预处理宏（preprocessor macro）¶

assert(expr);
- 首先对expr求值，为假则输出信息终止程序。为真什么都不做。
- assert宏定义在cassert头文件中,无需提供using声明
- 宏名在程序中必须唯一。
    - 含有cassert头文件的程序不能再定义名为assert的变量。
- 常用于检查“不能发生”的条件

NDEBUG预处理变量¶

assert 行为依赖NDEBUG预处理变量的状态。
- 如果定义了NDEBUG，assert 什么都不做
- 默认没有定义NDEBUG, assert 将执行运行时检查。

开关调试状态：
CC -D NDEBUG main.c 可以定义变量NDEBUG,避免检查开销
等价于在main.c文件里 #define NDEBUG

NDEBUG预处理变量¶

//利用NDEBUG 编写条件调试代码
//ndebug.cpp
//#define NDEBUG
#include<iostream>
using namespace std;
void print(){
    #ifndef NDEBUG
        cerr << __func__ << "..." << endl;//函数名
        cerr << __FILE__ << "..." << endl;//文件名
        cerr << __LINE__ << "..." << endl;//行号
        cerr << __TIME__ << "..." << endl;//编译时间
        cerr << __DATE__ << "..." << endl;//编译日期
    #endif
}
int main(){
    print();
    cout<<"hello"<<endl;
}
//g++ -D NDEBUG ndebug.cpp&& ./a.out

练习¶

改写使用递归输出vector内容的程序，使其有条件地输出与执行过程有关的信息。
例如，每次调用时输出vector对象的大小。
分别在打开和关闭调试器的情况下编译并执行这个程序。
#include <iostream>
#include <vector>
using std::vector; using std::cout; using std::endl;
void printVec(vector<int> &vec){
#ifndef NDEBUG
    cout << "vector size: " << vec.size() << endl;
#endif
    if (!vec.empty()){
        auto tmp = vec.back();
        vec.pop_back();//尾端删除元素
        printVec(vec); cout << tmp << " ";
    }}
int main(){
    vector<int> vec{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    printVec(vec);    cout << endl;
    return 0;
}

练习¶

说明下面这个循环的含义，它对assert的使用合理吗？
string s;
while (cin >> s && s != sought) { } //空函数体
assert(cin);

不合理。从这个程序的意图来看，应该用
assert(s == sought);

函数匹配¶

重载函数匹配的三个步骤：
1. 候选函数
  - 函数同名，调用点可见。
2. 可行函数
  - 形参实参数量相等，类型相同或可转。
  - 注意默认实参的情况
3. 寻找最佳匹配。
  - 类型越接近，匹配越好
  - 有二义性,编译器将报错

练习¶

什么是候选函数？什么是可行函数？

候选函数：与被调用函数同名，并且其声明在调用点可见。
可行函数：形参与实参的数量相等，并且每个实参类型与对应的形参类型相
    同或者能转换成形参的类型。

练习¶

已知函数f的声明，
void f();
void f(int);
void f(int,int);
void f(double,double=3.14);

对于下面的每一个调用列出可行函数。
其中哪个函数是最佳匹配？
如果调用不合法，是因为没有可匹配的函数还是因为调用具有二义性？

(a) f(2.56, 42)
(b) f(42)
(c) f(42, 0)
(d) f(2.56, 3.14)

练习¶

- (a) void f(int, int);和void f(double, double = 3.14);是可行函数。
该调用具有二义性而不合法。
- (b) void f(int); 是可行函数。调用合法。
- (c) void f(int, int);和void f(double, double = 3.14);是可行函数。
void f(int, int);是最佳匹配。
- (d) void f(int, int);和void f(double, double = 3.14);是可行函数。
void f(double, double = 3.14);是最佳匹配。

练习¶

编写函数f的4个版本，令其各输出一条可以区分的消息。

#include <iostream>
using std::cout; using std::endl;
void f(){
    cout << "f()" << endl;
}
void f(int){
    cout << "f(int)" << endl;
}
void f(int, int){
    cout << "f(int, int)" << endl;
}
void f(double, double){
    cout << "f(double, double)" << endl;
}

int main(){
    //f(2.56, 42); // error: 'f' is ambiguous.
    f(42);
    f(42, 0);
    f(2.56, 3.14);
    return 0;
}

实参类型转换¶

为确定最佳匹配，实参类型转换划为几个等级，排序如下
1. 精确匹配
    - 实参形参类型相同
    - 数组、函数转对应指针
    - 实参添加删除顶层const
2. 通过const转换实现匹配
3. 通过类型提升实现匹配
4. 通过算数类型转换、指针转换实现匹配
5. 通过类类型转换实现匹配

实参类型转换¶

void ff(int);
void ff(short);
ff('a'); //char  提升成int 调用f(int)

//所有的算数类型转换级别一样
void manip(long);
void manip(float);
manip(3.14); //错误，二义性调用

函数匹配和const实参¶

如果重载函数的区别在于引用类型的形参是否引用了const或指针类型的
形参是否指向cosnt，则编译器通过实参是否是常量决定选择那个函数。

Record lookup(Account&)
Record lookup(const Account&)
const Account a;
Account b;

lookup(a);//lookup(const Account&)
lookup(b);//lookup(Account&)

//指针类型的形参也类似

练习¶

已知有如下声明：
void manip(int ,int);
double dobj;
请指出下列调用中每个类型转换的等级。
(a) manip('a', 'z');
(b) manip(55.4, dobj);

- (a) 第3级。类型提升实现的匹配。
- (b) 第4级。算术类型转换实现的匹配。

练习¶

说明下列每组声明中的第二条语句会产生什么影响，并指出哪些不合法（如果有的话）。
(a) int calc(int&, int&); 
    int calc(const int&, const int&); 
(b) int calc(char*, char*);
    int calc(const char*, const char*);
(c) int calc(char*, char*);
    int calc(char* const, char* const);


(c) 不合法。顶层const不影响传入函数的对象。

函数指针¶

指向函数的指针。

bool lenthCompare(const string&,const string&);
函数类型是
bool(const string&,const string&)

//pf 指向一个函数，参数是两个const string&,返回值bool
bool (*pf)(const string &, const string &); 
//两端的括号不可少。

//表示名为pf的函数，返回bool*
bool *pf(const string &, const string &);

使用函数指针¶

pf = lenthCompare;//pf指向名为lenthCompare的函数
pf = &lenthCompare;//等价的赋值语句，取地址是可选的 

//函数指针使用
bool b1 = pf("hello","goodbye");//调用lenthCompare函数
bool b2 = (*pf)("hello","goodbye");//等价，同上，调用lenthCompare函数
bool b3 = lenthCompare("hello","goodbye");//等价，同上，调用lenthCompare函数

//指向不同函数类型的指针不存在转换规则
//可赋值nullptr 0
string::size_type sumLength(const string&,const string&);
bool cstringCompare(const char*,const char*);
pf=0;
pf=sumLength;//错误 类型不匹配
pf=cstringCompare ;//错误 类型不匹配
pf=lenthCompare;//正确 类型匹配

重载函数的指针¶

void ff(int*);
void ff(unsigned int);

void (*pf1)(unsigned int)=ff; //pf1指向ff(unsigned)

void (*pdf2)(int) = ff;//错误 没有匹配
double (*pdf2)(int*) = ff;//错误 没有匹配

函数指针形参¶

和数组类似，不能定义函数类型的形参，但形参可以是指向函数的指针
形参看起来是函数类型，实际当成指针使用

//第三个形参是函数类型，会自动转换成指向函数的指针
void useBigger(const string& s1, const string& s2,
                 bool pf(const string &,const string&));
//等价的声明，显式将形参定义成指向函数的指针
void useBigger(const string& s1, const string& s2,
                 bool (*pf)(const string &,const string&));

//把函数当实参使用，它会自动转换成指针
useBigger(s1,s2,lenthCompare);

函数指针形参¶

//使用类型别名和 decltype 简化函数指针代码
//Func Func2  是函数类型
typedef bool Func(const string&,const string&);
typedef decltype(lenthCompare) Func2; //等价的类型
//FuncP FuncP2是指向函数的指针
typedef bool (*FuncP)(const string&,const string&);
typedef decltype(lenthCompare) *FuncP2; //等价的类型

返回指向函数的指针¶

和数组类似，虽不能返回函数，但能返回指向函数的指针
必须把返回类型写成指针形式，编译器不会自动将函数返回类型当成对应的指针类型

using F=int(int*,int);//F是函数类型，不是指针
using PF=int(*)(int*,int);//PF是指针类型

//必须显式将返回类型指定为指针
PF f1(int); //正确，PF是指向函数的指针，f1返回指向函数的指针
F f1(int);  //错误，F是函数类型，f1不能返回一个函数
F *f1(int); //正确，显式指定返回类型是指向函数的指针

//直接声明f1
int (*f1(int))(int*,int);
//f1有形参列表,是函数。f1前面有*，所以返回指针。指针本身也包含形参列表，
//因此指针指向函数，函数返回值是int

//尾置返回类型的方式声明一个返回函数指针的函数
auto f1(int) -> int (*)(int*,int);

将auto和decltype 用于函数指针类型¶

string::size_type sumLength(const string&,const string&);
string::size_type largerLength(const string&,const string&);
//根据形参取值，getFcn函数返回指向sumLength或largerLength 的指针
decltype(sumLength) *getFcn(const string&);
//decltype 作用于函数时，返回函数类型并非指针类型，
//因此显式加上*表示需要返回指针，而非函数本身

练习¶

编写函数的声明，令其接受两个int形参并返回类型也是int；
然后声明一个vector对象，令其元素是指向该函数的指针。

int func(int, int);
vector<decltype(func)*> v;

练习¶

编写4个函数，分别对两个int值执行加、减、乘、除运算；
在上一题创建的vector对象中保存指向这些函数的指针。
int add(int a, int b) { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }
int divide(int a, int b) { return b != 0 ? a / b : 0; }

v.push_back(add);
v.push_back(subtract);
v.push_back(multiply);
v.push_back(divide);

练习¶

调用上述vector对象中的每个元素并输出结果。

std::vector<decltype(func) *> vec{ add, subtract, multiply, divide };
for (auto f : vec)
          std::cout << f(2, 2) << std::endl;

实践课¶

从课程主页 cpp.njuer.org 打开实验课函数界面
使用g++编译代码
编辑一个 readme.md 文档,键入本次实验心得.

使用git进行版本控制可使用之前的gitee代码仓库

  - 云服务器（elastic compute service,简称ecs）
  - aliyun linux 2是阿里云推出的 linux 发行版
  - vim是从vi发展出来的一个文本编辑器.
  - g++ 是c++编译器

习题1
//计算Ackermann函数的值 ack（2,2）
//ack（m,n）定义如下 m>=0,n>=0
//ack(0,n)=n+1
//ack(m,0)=ack(m-1,1)
//ack(m,n)=ack(m-1,ack(m,n-1))  (m>0,n>0)
习题2
//10阶台阶，每次只能上1级或者2级，走完这10级台阶共有多少种走法？
习题3
//从节点1到节点8有多少条路径？

附加题1
编写fact.cc 和factMain.cc ，编写 Chapter6.h 头文件。
通过这些文件，理解编译器是如何支持分离式编译的。

附加题2
手写简单的makefile，使用make命令对上题进行编译

附加题3
使用递归输出vector内容，使其输出与执行过程有关的信息。
例如，每次调用时输出vector对象的大小。
分别在打开和关闭调试器的情况下编译并执行这个程序。

编辑c++代码和markdown文档,使用git进行版本控制
yum install -y git gcc-c++
使用git工具进行版本控制
git clone你之前的网络git仓库test(或其它名字)
cd test 进入文件夹test
(clone的仓库,可移动旧文件到目录weekN:  mkdir -p weekN ; mv 文件名 weekN;)

vim test1.cpp
g++ ./test1.cpp 编译
./a.out 执行程序

vim test2.cpp
g++ ./test2.cpp 编译
./a.out 执行程序

vim test3.cpp
g++ ./test3.cpp 编译
./a.out 执行程序

git add . 加入当前文件夹下所有文件到暂存区
git config --global user.email "you@example.com"
git config --global user.name "Your Name"
vim readme.md 键入新内容（实验感想),按ESC 再按：wq退出
git add .
git commit –m "weekN" 表示提交到本地,备注weekN

git push 到你的git仓库

git log --oneline --graph 可看git记录
键入命令并截图或复制文字,并提交到群作业.
cat test* readme.md

提交¶

截图或复制文字,提交到群作业.
填写阿里云平台（本实验）的网页实验报告栏,发布保存.本次报告不需要分享提交
填写问卷调查 https://rnk6jc.aliwork.com/o/cppinfo

关于使用tmux¶

sudo yum install -y tmux
cd ~ && wget https://cpp.njuer.org/tmux && mv tmux .tmux.conf
tmux 进入会话 .
前缀按键prefix= ctrl+a, 
prefix+c创建新面板,
prefix+"分屏,
prefix+k选上面,prefix+j选下面,
prefix+1选择第一,prefix+n选择第n,
prefix+d脱离会话
tmux attach-session -t 0 回到会话0

vim 共分为三种模式¶

- 命令模式
  - 刚启动 vim,便进入了命令模式.其它模式下按ESC,可切换回命令模式
    - i 切换到输入模式,以输入字符.
    - x 删除当前光标所在处的字符.
    - : 切换到底线命令模式,可输入命令.
- 输入模式
  - 命令模式下按下i就进入了输入模式.
    - ESC,退出输入模式,切换到命令模式
- 底线命令模式
  - 命令模式下按下:（英文冒号）就进入了底线命令模式.
    - wq 保存退出

vim 常用按键说明¶

除了 i, Esc, :wq 之外,其实 vim 还有非常多的按键可以使用.命令模式下：
- 光标移动
  - j下 k上 h左 l右
  - w前进一个词 b后退一个词
  - Ctrl+d 向下半屏  ctrl+u 向上半屏
  - G 移动到最后一行 gg 第一行 ngg 第n行
- 复制粘贴
  - dd 删一行 ndd 删n行
  - yy 复制一行 nyy复制n行
  - p将复制的数据粘贴在下一行 P粘贴到上一行
  - u恢复到前一个动作 ctrl+r重做上一个动作
- 搜索替换
  - /word 向下找word     ？word 向上找
  - n重复搜索 N反向搜索
  - :1,$s/word1/word2/g从第一行到最后一行寻找 word1 字符串,并将该字符串
    取代为 word2

vim 常用按键说明¶

底线命令模式下：
- :set nu   显示行号
- :set nonu 取消行号
- :set paste    粘贴代码不乱序
【注：把caps lock按键映射为ctrl,能提高编辑效率.】

Markdown 文档语法¶

# 一级标题
## 二级标题
*斜体* **粗体**
- 列表项
  - 子列表项
> 引用
[超链接](http://asdf.com)
![图片名](http://asdf.com/a.jpg)

|表格标题1|表格标题2|
 |-|-|
|内容1|内容2|