一.基础

1.无参函数

#include <iostream>
#include <string>

//无参数,无返回值
void SayHello()
{
    std::cout << "Hello" << std::endl;
}
//效果相同
void SayHello2(void)
{
    std::cout << "Hello" << std::endl;
}

2.有参函数

//有参数,无返回值
void Subtract(int a,int b)
{
    std::cout << "result:";
    std::cout << a-b << std::endl;
}

3.有返回值

//有返回值
int Max(int a,int b)
{
    if(a>b)
        return a;
    return b;
}

测试代码

SayHello();
Subtract(10,5);
std::cout << "Max result:";
std::cout << Max(11,22)<< std::endl;

二.传参

1.非引用形参(值类型复制)

//无效
void Zero1(int p)
{
    p=0;
}

2.指针形参

//更改有效
void Zero2(int *p)
{
    *p=0;
}

注意:两者都是需要复制

Test

    int i = 42;
    int *p = &i;
    std::cout << "i: " << i << '\n';   // prints i: 42
    Zero1(i);
    std::cout << "i: " << i << '\n';   // prints i: 42
    Zero2(p);
    std::cout << "after i: " << i << '\n';   // prints i: 0

3.const形参(参数不可更改)

//编译通过
int Fix(int a)
{
    if(a>10)
      a=10;
    return a;
}

int ReadFix(const int a)
{
    //错误，无法编译
    if(a>10)
      a=10;
    return a;
}

4.引用形参(引用是别名)

经典的swap方法

//无效
void swap1(int v1, int v2)
{
    int tmp = v2;
    v2 = v1;    
    v1 = tmp;
}    

//有效
void swap2(int &v1, int &v2)
{
    int tmp = v2;
    v2 = v1;
    v1 = tmp;
}

Test1

int i = 10;
int j = 20;
cout << "Before swap():\ti: "
     << i << "\tj: " << j << endl;
swap1(i, j);
cout << "After swap():\ti: "
     << i << "\tj: " << j << endl;

Test2换做swap2的结果

5.const引用

bool isShorter(const string &s1, const string &s2)
{
    return s1.size() < s2.size();
}

不对引用进行修改和复制

6.更灵活的const引用

 int incr(int &val)
{
    return ++val;
}

int main()
{
         short v1 = 0;
         const int v2 = 42;
         int v3 = incr(v1);   // error: v1 is not an int
         v3 = incr(v2);       // error: v2 is const
         v3 = incr(0);        // error: literals are not lvalues
         v3 = incr(v1 + v2);  // error: addition doesn't yield an lvalue
         int v4 = incr(v3);   // ok: v3 is a non const object type int
         return 0;
}

非const引用形参只能与完全同类型的非const对象关联,要求非常严格.