c++Primer第六章：函数

ゝ一世哀愁。 2022-11-12 15:59 173阅读 0赞

# 函数参数传递 #

**尽量使用指针和引用，传递地址，避免拷贝浪费**

## 1.指针型参数 ##

void resert(int *p){ 
    	p = 0;//改变指向无效
    	*p = 0;//实际只有这个起作用
    }

## 2.传引用参数 ##

void print_s(string &s){ 
    	for(auto &e : s){ 
    		if(e=='i')
    			e='O'; 
    	}
    	for(auto e : s)
    		cout<<e<<" ";
    	cout<<endl;
    }
    string t = "it just a test,this";
    print_s(t);

输出  
![在这里插入图片描述][20210324170434161.png]  
如果没有改变参数内容那么就定义为const引用类型

bool lengthCompare(const string & a,const string & b){ 
    	return a.length()>b.length();
    }
    string a与“hello word"类型都能接收

还可以使用引用返回额外的参数  
leetcode的树高，图的遍历啥的用的比较多，给的是地址就是修改地址上的数据。

## 3.const 形参和实参 ##

顶层const不能使函数重名，实参初始化形参时会忽略上层const，以下两个函数是一致的，第二个重复定义了第一个

void fun(const int i);
    void fun(int i);

## 4.数组形参 ##

### 1.C风格字符串以/0结束 ###

void print(const char *cp)
    { 
    	if(cp)
    		while(*cp)
    			cout<<*cp++;	
    }

### 2.数组标准库 ###

void print (const int *begin,const int *end){ 
    	while(beg!=end){ 
    		cout<<*beg<<endl;
    		beg++;}
    }
    int j[2] = { 0,1};
    print(begin(j),end(j));

### 3.把数组长度传进去 ###

void print(const int ia[],size_t size){ ...}

#### 4.数组引用形参 ####

关于数组的引用

void print(int (&arr)[10]){ 
    	for(auto elem : arr){ ...}
    }
    int k[10]={ 1,2,3,4,5,6,7,8,9,10};
    print(k);

关于vector的引用

void print(vector<int> a){ ...}
    void print(vector<int> &a){ ...}

### 5.main函数传递参数 ###

int main(int argc ,char **argv){ 
    	int i;
    	cout<<"argc="<<argc<<endl;
    	for(i=0;i<=argc;i++)
    		cout<<argv[i]<<endl;
    	return 0;	 
    }

结果。输入的数据其实在argv\[1-5\]中存储，argv\[0\]是程序的名字  
![在这里插入图片描述][20210324180359635.png]

### 6.可变参数的函数 ###

初始化什么的操作和vector一致，但是里面是常量值不可修改

void error_msg(initializer_list<string> il){ 
    	for(auto e : il)
    		cout<<e<<" ";
    	cout<<endl;
    } 
    error_msg({ "this","is","a","test"});
    error_msg({ "so","ok"});

### 7.省略符形参 ###

省略有类型进行类型检测，省略号的不进行类型检测

void NormalLog(ModLog *mlog,const char* format,...)

# 返回值 #

## 有返回值 ##

### 1.返回const 引用 ###

在没有修改的时候，可以返回引用，降低拷贝次数

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

### 2.引用返回左值 ###

string &changeString (string &s1,string &s2){ 
    	return s1.size()<s2.size()?s1:s2;
    }
    	string s1="it is s1";
    	cout<<s1<<endl;
    	string s2="it is ss2";
    	changeString(s1,s2)[0]='x';
    	cout<<s1<<endl;

结果  
![在这里插入图片描述][20210324185527543.png]

### 3.返回列表 ###

vector<string> process(){ 
    	return { "test1","test2","test3"};
    }

### 4.主函数返回值 ###

#include<cstdlib>
    int main(){ 
    	if(some_failure){ 
    		return EXIT_FAILLURE;
    	}
    	else return EXIT_SUCCESS;
    }

### 5.返回数组指针 ###

尾置返回类型，返回指向10个整数的数组

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

直接返回指针类型

int *arrPtr(int *s1,int *s2,int i){ 
    	return (i%2)? s1 : s2; 
    }
    
    int odd[] = { 1,3,5,7,9};
    int even[] = { 0,2,4,6,8};
    int *s = arrPtr(odd,even,1);
    cout<<"test:"<<s[0]<<" "<<sizeof(s) <<" "<<sizeof(odd)<<endl;

结果  
![在这里插入图片描述][20210324203039248.png]

decltype类型  
返回一个指针，该指针指向含有5个整数的数组

int odd[] = { 1,3,5,7,9};
    int even[] = { 0,2,4,6,8};
    decltype(odd) *arrPtr(int i){ 
    	return (i%2)? &odd : &even; 
    }
    int main(){ 
        decltype(odd) *t = arrPtr(2);
    	cout<<"test t "<<(*t)[0]<<endl;
        return 0;
    }

输出结果  
![在这里插入图片描述][20210324205120201.png]

# 函数重载 #

## 1.名字一样参数不一样，但是顶层const不能做参数不同的标志，左定值，右定项 ##

void Lookup(Phone) == void Lookup(const Phone);
    void Lookup(Phone*) == void Lookup(Phone *const);

关于这种需要有const的重载，输入参数为非常量的时候，输出为非常量，输入参数为常量，输出为常量

const string &shortString (const string &s1,const string &s2){ 
    	return s1.size()<s2.size()?s1:s2;
    }
    
    string &shortString(string &s1,string &s2){ 
    	auto &r = shortString(const_cast<const string&>(s1),const_cast<const string&>(s2));
    	cout<<"no const"<<endl;
    	return const_cast<string&>(r);
    }
    
    cout<<shortString(s1,s2)<<endl;

输出  
当有非常量的对象时，系统优先使用非常量版本的函数  
![在这里插入图片描述][20210325103548712.png]

## 2.内联函数和constexpr函数 ##

内联函数，在函数前面加inline，优化规模小，流程简单，频繁调用的函数  
constexpr：常量表达式函数，返回值形参类型都是字面值类型，函数体中只有一条return语句，被定义为隐式内联函数，根据参数，返回的可能不一定是常量表达式。

constexpr int new_size(){ return 42;}
    constexpr int foo = new_sz();

## 3.调试帮助 ##

### 1.调试代码以及屏蔽调试代码 ###

#include<cassert>
    int arr2[1000];
    assert(sizeof(arr2)<1000);

输出信息并终止程序  
结果  
![在这里插入图片描述][20210325105629880.png]  
注：cerr和cout区别  
cout可以输出在文本中，cerr不行，不能重定向只能输出在显示器。

cout<<"cout"<<endl;
    	cerr<<"cerr"<<endl;

test >>cout.txt命令，生成的text只有cout，但是屏幕上两个都有。

### 2.条件编译 ###

#define DEBUG
    #define NDEBUG
    void print_w(){ 
    	#ifdef DEBUG
    	cerr<<"ifdef DEBUG"<<endl;
    	cerr<<" func:"<<__func__<<endl;//函数名称
    	cerr<<" File:"<<__FILE__<<endl;//文件
    	cerr<<" Line:"<<__LINE__<<endl;//行数
    	cerr<<" Time:"<<__TIME__<<endl;//时间
    	cerr<<" Date:"<<__DATE__<<endl;//日期
    	#endif
    	#ifndef NDEBUG
    	cerr<<"ifdnef NDEBUG"<<endl;
    	cerr<<" func:"<<__func__<<endl;
    	cerr<<" File:"<<__FILE__<<endl;
    	cerr<<" Line:"<<__LINE__<<endl;
    	cerr<<" Time:"<<__TIME__<<endl;
    	cerr<<" Date:"<<__DATE__<<endl;
    	#endif
    }

结果  
![在这里插入图片描述][20210325114946834.png]  
注意  
我是华文彩云  
ifdef和endif一般在头文件中用的比较多，防止重复定义基本上就是头文件重复包含，使用方式把.h里的东西都包含在这里面，比如类的定义

#ifndef   _aaa_   
     #define   _aaa_   
     class   aaa   {    
    	 };   
     #endif

# 函数指针 #

## 1.函数指针的声明 ##

bool lengthCompare(const string & a,const string & b){ 
    	return a.length()>b.length();
    }

bool (*pf)(const string &,const string &);
    bool test1 = lengthCompare("sss","bbbbb");
    pf = &lengthCompare;
    bool test2 = pf("as","a");
    cout<<test1<<" "<<test2<<endl;

结果  
![在这里插入图片描述][20210325120502567.png]

## 2.函数指针形参 ##

void useBigger(const string &s1,const string &s2,bool (*pf)(const string &,const string &)){ 
    	if(pf(s1,s2))
    		cout<<pf(s1,s2)<<" "<<s1<<endl;
    	else
    		cout<<pf(s1,s2)<<" "<<s2<<endl;
    }

bool (*pf)(const string &,const string &);
    bool test1 = lengthCompare("sss","bbbbb");
    pf = &lengthCompare;
    bool test2 = pf("as","a");
    cout<<test1<<" "<<test2<<endl;
    cout<<"useBigger:"<<endl;
    useBigger("sss","bbbbb",pf);

结果  
![在这里插入图片描述][20210325121535672.png]  
相同的操作，使用decltype获取函数类型进行相应操作

指向函数的指针
    typedef decltype(lengthCompare) *func1;
    函数类型
    typedef decltype(lengthCompare) func2;

声明函数的时候使用

void useBigger(const string &s1,const string &s2,func1);
    void useBigger(const string &s1,const string &s2,func2);

## 3.返回函数指针 ##

建议尾置型，看的懂

auto f1(int) -> int(*)(int*,int)

如果两个函数返回类型一致，可以编写一个函数指针，根据某些条件返回两个中的一个

const string &shorterString (const string &s1,const string &s2){ 
    	return s1.size()<s2.size()?s1:s2;
    }
    const string &longerString (const string &s1,const string &s2){ 
    	return s1.size()<s2.size()?s2:s1;
    }
    decltype(shorterString) *getFun(const string &t){ 
    	if (t=="s")
    		return shorterString;
    	else
    		return longerString;
    }

auto f1 = getFun("s");
    cout<<"f1:"<<f1("aaa","aa")<<endl;
    auto f2 = getFun("l");
    cout<<"f2:"<<f2("aaa","aa")<<endl;

结果  
![在这里插入图片描述][20210325125836125.png]

[20210324170434161.png]: /images/20221022/e9e89ba0a74d483597510653d810a1ef.png
[20210324180359635.png]: /images/20221022/fe4113128d4f4194888343330de011c9.png
[20210324185527543.png]: /images/20221022/b0dab6883f544a2f9039b1e8ad55b1a8.png
[20210324203039248.png]: /images/20221022/b0f32daae56e4177863332fca36d6f96.png
[20210324205120201.png]: /images/20221022/6ce091ccd80946a18e297387cb07f9b6.png
[20210325103548712.png]: /images/20221022/ece925e7778d4af081f97ae91473def0.png
[20210325105629880.png]: /images/20221022/121d1f2ef6eb4e9fb1fa05c965ca4a34.png
[20210325114946834.png]: /images/20221022/4b7df3c80a8c4e96bf189a8a4b265f2e.png
[20210325120502567.png]: /images/20221022/106119db2ccc4a1b99ef51f66e90740e.png
[20210325121535672.png]: /images/20221022/b534be8bcd874fceb971db5d6b5c267b.png
[20210325125836125.png]: /images/20221022/93e50e32f78b47cda2597e1acf43dbc7.png