C++——函数及调用

1.函数调用：实参初始化形参；控制权交给被调函数

2.函数返回（return语句）：返回return中的值；控制权交回主函数

3.参数传递

	传值	传引用	传指针
初始值	不变，拷贝给形参	可变，形参是实参的别名 若不想变，加const	拷贝指针给形参

//1.传指针
void reset(int *p)
{
  *ip=;//改变了指针所指向对象的值
  ip=;// 只改变ip的局部拷贝，实参未被改变。指针本身可以在局部内任意变化，但指针指向的值没变
}
int i=;
reset(&i);//改变I的值，而非地址
cout<<i<<endl;//i=0

//2.传引用
void reset(int &i)
{
    i=;
}
int j=;
reset(j);//改变I的值，而非地址
cout<<j<<endl;//j=0

4.const参数传递

void reset(int &i)//引用传递
{
    i=;
}

void reset(int *ip)//指针传递
{
    *ip=;
}

int i=;
const int ci=i;
string::size_type ctr=;

reset(i);//引用传递
reset(&i);//引用传递
reset(ci);//×，int类型不能传递给const int类型
reset(&ci);//×，const in *类型不能传递给int *类型
reset();//×
reset(ctr);//×

如果函数参数是const呢？能接受什么参数传入？

5.数组形参

//三个函数等价，形参是const int*
void print(const int*);
void print(const int[]);//
void print(const int[]);//期望含有10个元素的数组，实际不一定，那实际怎么操作，如果元素>10的话？

int i=,j[]={,};
print (&i);//int*类型
print(j);//自动转为int *

5.1 判断数组长度

　　1.使用标记（字符串末尾空）

void print(const char*cp)
{
    if(cp)
    {
         while(*cp)//判断方法
            cout<<*cp++
    }
}

　　2.使用标准库

void print(const int *beg,const int *end)
{
  while (beg!=end)
      cout<<*beg++<<endl;
}

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

　　3.显式传递大小

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

6.main命令行，传递参数

int main(int argc, //
    char *argv[])//argv是数组，元素是char*指针
{
}

//与上式等价
int main(int argc,//
    char ** argv)//argv  指向char*
{
}

prog -d -o file data0//可执行文件prog，输入参数
//argc=5
//argv[0]= "prog";
//argv[1]= "-d";
//argv[2]="-o";
//argv[3]=" file";
//argv[4]=" data0";

7.可变形参

7.1 类型相同，数量不同——initializer_list标准库类型

常量值，无法改变，只读

void error_msg(initializer_list<string> istring)
{
  for (auto beg=istring.begin();beg!=istring.end();++beg)
        cout<<*beg<<" ";
  cout << endl;
}

if (expected !=actual)//2 个string 对象
    error_msg({"FunctionX output:",expected, actual });//{}用于传递initializer_list序列
else
    error_msg({"FunctionX output:","Okay"});

可根据实际改写为先打印错误代码，再打印内容：

void error_msg(ErrorCode e, initializer_list<string> string)
{
  cout<<e.print()<<":"
  for (const auto & elem:string)
      cout<< elles<<" ";
  cout<<endl;
}

7.2 省略符形参：varargs标准库

8.函数返回

8.1 不要返回局部对象的引用或指针

8.2 返回数组

1.声明返回数组指针的函数

int (*func(int i))[];//解引用的结果是一个10个int元素的数组
//func(int i):
//(*func(int i)):对函数调用的结果解引用
//

2.尾置返回？

auto func(int i)->int(*)[];

3.decltype返回？

int odd[]={,,,,};
int even[]={,,,,};
decltype (odd) *arrptr(int i)//decltype不会把数组转为指针
{
  return (i%)?&odd:&even;  //返回一个指针，该指针指向含有5个整数的数组
}

9.函数重载

9.1.不能定义两个除了返回值类型不同外，其他都相同的函数

9.2 有时候两个形参看起来类型不一样，实际上相同，也是不许的

9.3 带顶层const的形参和不带const的形参是无法区分的

bool lookUp(Phone);//
bool lookUp(const Phone);//2,与1重复。／？
bool lookUp(Phone*);//
bool lookUp(Phone* const);//4，与3重复。／？

bool lookUp(Phone&);//5，作用于Phone的引用
bool lookUp(const Phone&);//6，作用于常引用，同时存在会优先选用
bool lookUp(Phone*);//7，作用于指向Phone的指针
bool lookUp(const Phone *)//8，作用于指向常量的指针，同时存在会优先选用

10.默认实参：一旦有一个参数为默认，其他必须给默认值

string screen(size_type hight=, size_type width=);

window=screen();
window=screen(100,200);

11.内联函数

1.定义在头文件中（文件中多次要用）

12.constexpr函数

1. 函数的返回类型、形参类型都是字面值类型

2.函数中有且仅有一条return语句

3.定义在头文件中

constexpr int new_size()
{
    return ;
}

constexpr size_t scale(size_t cnt)
{
    return new_sz()* cnt;
}

int arr[scale()];

13.函数调用时的实参匹配

1.精确匹配

2.const转换实现匹配

3.类型提升实现匹配

4.算术类型转换（或指针转换）实现匹配

5.类类型转换实现匹配

bool lookUp(Account &);
bool lookUp(const Account &);

Account b;
lookUp(b);//两个都可以调用，但是第一个优先

14.函数指针

bool lengthCompare(const string &,const string &);

bool (*pf)(const string &,const string &);//pf是指向函数的指针
//bool *pf(const string &,const string &);//声明一个名为pf的函数，返回bool *

pf = lengthCompare;
pf =& lengthCompare;//与上等价

bool b1=pf("hello","goodbye");
bool b2=(*pf)("hello","goodbye");
bool b3=lengCompare("hello","goodbye");／／三式等价

14.1 返回指向函数的指针

14.2 auto 和decltype用于函数指针类型