精华内容
下载资源
问答
  • 2019-03-21 09:20:42

    目录

    C标准库

    <string.h>头文件

    1. memset()
    2. memcpy()
    3. strcpy()
    4. strncpy()
    5. stract()
    6. getline()
    7. strlen()

    <ctype.h>头文件

    1. tolower()/toupper()
    2. isalpha()、isdigit()、isprint()

    <math.h>头文件

    1. pow()
    2. floor()
    3. atan()

    STL

    头文件

    1. min(),max()函数
    2. lower_bound()
    3. upper_bound()
    4. next_permutation()/prev_permutation()
    5. Sort()
    6. fill()

    C标准库
    <string.h>头文件
    1.memset()
    函数原型:memset(void *s , int c , size_t n)

    作用:将已开辟内存空间s的首n个字节的值设置为c。一般用于在对字符串进行初始化为‘\0’或‘ ’

    注意:
    1.s为首地址,c为要赋予的字符,n为长度
    2.一般不用于初始化数字数组

    代码示例:

    #include<stdio.h>
    #include<string.h>
     
    int main(){
    	char str[5]={'1','2','3','4','5'};
    	
    	printf("原始字符数组:");
    	for(int i=0;i<5;i++)
    		printf("%c ",str[i]);
    	printf("\n");
    	
    //	内存初始化 
    	memset(str,'\0',5);
    	
    	printf("初始化后的字符数组:");
    	for(int i=0;i<5;i++)
    		printf("%c ",str[i]);
    		
    	return 0;
    }
    

    2.memcpy()
    函数原型:void *memcpy(void *dest, const void *src, size_t n);

    作用:将以src开头,长度为n的内存空间里的内容拷贝到以dest开头的内存空间里去。

    例:

    char a[100],b[50];
    memcpy(b,a,sizeof(b)); //将a的sizeof(b)个元素赋给b
    注意:如果用sizeof(a),会造成b的内存地址溢出。

    3.strcpy()
    函数原型:char strcpy(char dest, const char *src);

    作用:把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间

    例:

    char a[100],b[50];
    strcpy(a,b);
    注意:遇到‘\0’时就结束拷贝。

    4.strncpy()
    函数原型:strncpy(char* dest,const char* src,int n)

    作用:把src所指的字符串中以src地址开始的前n个字节复制到dest所指的空间中,并返回dest。

    注意:
    1.结果dest不包括结束符NULL(’\0’)
    2.如果src的长度小于n个字节,则以NULL填充dest直到复制完n个字节

    5.stract()
    函数原型:char *strcat(char *dest, const char *src);

    作用:将两个char类型数组相连,结果放在dest中,返回拼接后指向dest的指针。

    6.getline()
    函数原型:istream& getline ( istream &is , string &str , char delim );

    参数解释
    is 进行读入操作的输入流,常用cin
    str 已声明的用于存储读入内容的对象,常为string类型
    delim 终结符

    作用:
    将输入流is中读到的字符存入str中,直到遇到终结符delim才结束。如果没有定义delim,则默认为 ‘\n’(换行符)。

    注意:
    getline遇到delim时停止读入(但读入了delim),然后将所读内容存储到string对象中(不存delim)下次读入操作时,将在delim的下个字符开始读入。

    代码示例:

    #include<stdio.h>
    #include<string.h>
     
    int main(){
    	string str;
    	getline(cin,str,'o');
    	printf("%s",str.c_str());  // string类型字符串不能直接使用printf输出,需要调用string中的c_str()函数
    }
    

    7.strlen()
    函数原型:size_t strlen(const char *string);

    作用:计算string字符串或者以char *声明的字符数组的长度。

    <ctype.h>头文件
    1.tolower()/toupper()
    作用:改变字母大小写

    例:

    char n=’h’;
    cout<<(char)toupper(n); //输出结果为‘H’
    注意:n的值并没有改变,仍然为‘h’。

    2.isalpha(),isdigit(),isprint()
    作用:用来对是否是字母,数字,可打印字符(非控制字符)进行判断

    <math.h>头文件
    1.pow()
    函数原型:double pow(double x, double y)

    作用:返回x的y次方

    2.floor()
    函数原型:double floor(double x);

    作用:用于输出浮点类型中小于此数的最大整数

    注:floor(n+0.5)可用于进行四舍五入的处理

    3.atan()
    作用:用来求π的值:atan(1)=π/4 π=4.0*atan(1)

    代码示例:

    #include<iostream>
    #include<math.h>        
    using namespace std;
     
    // 求π的值,保留小数点后15为小数
    int main(){
        double pi = 4*atan(1);
        printf("%.15f",pi);     //保留π后的十五位小数
    }
    

    STL
    头文件
    1.min(),max()函数
    作用:返回两个元素中最小(最大)的一个

    2.lower_bound()
    函数原型:lower_bound(int* first,int* last,val);

    作用:查找有序区间[first,last]中第一个大于等于x的位置

    代码示例:

    #include<iostream>
    #include<algorithm>
    using namespace std;
     
    int main(){
    	int n[10];
    	for(int i=0;i<10;i++)
    		n[i]=i;
    	
    	cout<<"第一个大于等于7的位置:"<<lower_bound(n,n+9,7)<<endl;
    	cout<<"该位置上的值:"<<*lower_bound(n,n+9,7)<<endl;
    	
    	return 0;
    }
    

    3.upper_bound()
    作用:大致和lower_bound()相同,不过查找的是有序区间[first,last]中第一个大于x的位置

    4.next_permutation()/prev_permutation()
    格式:next_permutation(数组名,数组名+数组长度)

    作用:
    将数组的排序改为当前数组全排列的下/上一个

    返回值:
    若当前数组存在下/上一个全排列,则返回ture,否则返回false。

    解释:
    假设数组为a,b,c。则该数组的全排列为abc,acb,bac,bca,cab,cba。若当前数组为bac,则其全排列的上一个数组即为acb,下一个数组为bca

    注意:
    若要求数组所有的全排列,需要将数组进行升序排列,否则只能找出该序列之后的全排列数。

    代码示例:

    #include<iostream>
    #include<algorithm>
    using namespace std;
     
    //输出abc的全排列 
    int main(){
    	char ans[3]={'a','b','c'};
    	do{
            for(int i=0;i<3;++i)
                cout<<ans[i]<<" ";
             cout<<endl;
        }while(next_permutation(ans,ans+3));
    		        
    	return 0;
    } 
    

    6.Sort()
    函数原型:void sort(RanIt first, RanIt last, Pred pr);

    参数解释
    first 指向容器首地址的指针(数组名)
    last 指向容器尾地址的指针(数组名+数组长度)
    pr 比较方法(默认为升序)
    具体用法:

    sort(begain,end,less<数据类型>())   升序
    sort(begain,end,greater<数据类型>()) 降序   
    

    注意:开始和结尾用的都是指针

    示例代码:

    #include<iostream>
    #include<algorithm>
    using namespace std;
     
    int main(){
    	 char ch[5]={'e','a','c','b','d'};
    	 cout<<"原字符数组为:"<<ch<<endl; 
    //	 升序排列 
    	 sort(ch,ch+5);
    	 cout<<"升序排列后为:"<<ch<<endl;
    //	 降序排列 
    	 sort(ch,ch+5,greater<char>());
    	 cout<<"降序排列后为:"<<ch<<endl;
    	 
    	 return 0;
    } 
    

    7.fill()
    函数原型:void fill(first,last,val);

    参数解释
    first 起始地址
    last 末尾地址
    val 将要替换的值
    作用:可将数组的值初始化成指定值

    例如:
    1.初始化一维数组
    int a[10];
    fill(a,a+10,80);

    2.初始化二维数组
    int a[10][10];
    fill(a[0],a[0]+10*10,90);

    更多相关内容
  • C++ 库函数大全手册完整版,而且是chm格式带索引、搜索,用着非常方便。这本手册的内容涉及C++ 核心库函数、STL函数、C函数库、IOstream操作库、STL Containers、Strings library字符串库等常用的函数集,一查即应,...
  • C++常用函数汇总(持续更新)

    千次阅读 2021-08-10 11:24:17
    注:写这篇文章是为了平时学习积累噢!文中的内容都表明出处啦,我只写了大概,不如原博主写的好,大家见谅哈~ 目录vectoraccumulate ...2、Vector作为函数的参数或者返回值时,需要注意它的写法: double Distan

    注:写这篇文章是为了平时学习积累噢!文中的内容都表明出处啦,我只写了大概,不如原博主写的好,大家见谅哈~

    vector

    作用:它能够像容器一样存放各种类型的对象,简单地说,vector是一个能够存放任意类型的动态数组,能够增加和压缩数据。

    特别注意:

    使用vector需要注意以下几点:

    1、如果你要表示的向量长度较长(需要为向量内部保存很多数),容易导致内存泄漏,而且效率会很低;

    2、Vector作为函数的参数或者返回值时,需要注意它的写法:

    double Distance(vector&a, vector&b) 其中的“&”绝对不能少!!!

    实例:vectortest;

    //建立一个vector,int为数组元素的数据类型,test为动态数组名

    简单的使用方法如下:

    vector<int>test;//建立一个vector
    
    test.push_back(1);
    
    test.push_back(2);//把1和2压入vector,这样test[0]就是1,test[1]就是2
    
    vector<vector<Point2f> > points; //定义一个二维数组
    
    points[0].size();  //指第一行的列数
    

    基本操作

    (1)头文件#include.

    (2)创建vector对象,vector vec;

    (3)尾部插入数字:vec.push_back(a);

    (4)使用下标访问元素,cout<<vec[0]<<endl;记住下标是从0开始的。

    (5)使用迭代器访问元素.

    vector<int>::iterator it;
    
    for(it=vec.begin();it!=vec.end();it++)
    
        cout<<*it<<endl;
    
    

    (6)插入元素: vec.insert(vec.begin()+i,a);在第i+1个元素前面插入a;

    (7)删除元素: vec.erase(vec.begin()+2);删除第3个元素

    vec.erase(vec.begin()+i,vec.end()+j);删除区间[i,j-1];区间从0开始

    (8)向量大小:vec.size();

    (9)清空:vec.clear();
    算法

    • 使用reverse将元素翻转:需要头文件 #include<algorithm>

    reverse(vec.begin(),vec.end());将元素翻转,即逆序排列!

    (在vector中,如果一个函数中需要两个迭代器,一般后一个都不包含)

    • 使用sort排序:需要头文件#include,

    sort(vec.begin(),vec.end());(默认是按升序排列,即从小到大).

    可以通过重写排序比较函数按照降序比较,如下:

    定义排序比较函数:

    bool Comp(const int &a,const int &b)
    {
        return a>b;
    }
    

    调用时:sort(vec.begin(),vec.end(),Comp),这样就降序排序。

    • 输出Vector的中的元素
    vector<float> vecClass; 
    
    int nSize = vecClass.size();   
    

    //打印vecClass,方法一:

    for(int i=0;i<nSize;i++)  
    {  
       cout<<vecClass[i]<<"     ";  
    }  
       cout<<endl; 
    

    需要注意的是:以方法一进行输出时,数组的下标必须保证是整数。
    //打印vecClass,方法二:

    for(int i=0;i<nSize;i++)  
    {  
       cout<<vecClass.at(i)<<"     ";  
    }  
       cout<<endl;  
    

    //打印vecClass,方法三:输出某一指定的数值时不方便

    for(vector<float>::iterator it = vecClass.begin();it!=vecClass.end();it++)  
    {  
        cout<<*it<<"   ";  
    }  
        cout<<endl;  
    

    二维数组的使用:

    #include "stdafx.h"
    #include <cv.h>
    #include <vector> 
    #include <iostream> 
    using namespace std;
    int main()
    {
    	using namespace std;
    	int out[3][2] = { 1, 2, 
    			 3, 4,
    			5, 6 };
    	vector <int*> v1;
     
    	v1.push_back(out[0]);
    	v1.push_back(out[1]);
    	v1.push_back(out[2]);
     
    	cout << v1[0][0] << endl;//1
    	cout << v1[0][1] << endl;//2
    	cout << v1[1][0] << endl;//3
    	cout << v1[1][1] << endl;//4
    	cout << v1[2][0] << endl;//5
    	cout << v1[2][1] << endl;//6
     
    	return 0;
    }
    

    转自博主 那年聪聪

    使用const引用是一个好习惯(const 修饰容器,则初始化后不能增删元素也不能修改元素,也不能改变容器大小 ,也就说不能做任何改动。)
    在C++中容器都是值拷贝的,因此不使用引用的话,会大量拷贝垃圾数据.其实,可以这么说C/C++是值拷贝编程语言。不使用额外的技术,比如指针、引用,都会发生垃圾数据的拷贝。当然,到底是不是垃圾数据由你自己决定,值拷贝是无法彻底摒弃的。

    c++中vector和vector<int*>的用法比较(转自 军说网事)

    accumulate

    accumulate定义在#include<numeric>中,作用有两个,一个是累加求和,另一个是自定义类型数据的处理

    • 算法简介:accumulate(iterator beg, iterator end, value);
      计算容器元素累计总和;[beg,end)为起始迭代器和结束迭代器,vaule为起始值 。

    主要用于数值的累加求和、字符串的连接。

    例子
    使用accumulate(iterator beg, iterator end, value)函数计算vector容器中所有元素(0-100)的和,其初始值为1000

    #include<iostream>
    #include<vector>
    #include<string>
    #include<numeric>
    using namespace std;
     
    // 常用算术生成算法: accumulate(iterator beg, iterator end, value); 计算[beg,end)区间中所有元素的和
    // all = value + sum(beg,end) 
     
    void test01(){
    	
    	vector<int> vec;
    	for(int i=0; i<=100; i++){
    		vec.push_back(i); 
    	} 
    	
    	vector<string> vecs;
    	vecs.push_back("Hello");
    	vecs.push_back("World");
    	vecs.push_back("!");
    	
        // 对string类型进行累积
    	string sunStr = accumulate(vecs.begin(), vecs.end(), string(""));
    	
    	// 计算vec容器中所有元素的总和 
    	int sumNum = accumulate(vec.begin(), vec.end(), 1000);
    	
    	cout << "vec容器中元素的总和为:" << sumNum << endl;
    	cout << "vecs为:" << sunStr << endl;
    	
    }
     
    int main(){
    	
    	test01();
    	
    	system("pause");
    	return 0;
    	
    } 
    

    在这里插入图片描述
    转自博主 凉冰难消一腔热血
    构建二维动态数组

    int **p;
    p = new int*[10];    //注意,int*[10]表示一个有10个元素的指针数组
    for (int i = 0; i < 10; ++i)
    {
        p[i] = new int[5];
    }
    

    定义二维vector

    vector<vector<int>> v;
    

    访问二维vector的元素的三种方式
    如果指定外层和内层向量的大小,就可用operator[]进行读和写;如果只指定外层向量大小,就能用push_back()函数进行写,不能用operator[]进行读和写。

    1. 指定外层vector大小

    可用push_back函数进行初始化:

    v.resize(3);
    v[1].push_back(9);
    
    1. 遍历指定内层vector大小
      提前设定好每行vector的大小,就可用operator[]访问,如下:
    for(int i=0;i<3;i++)
        v[i].resize(3);
    
    1. 一次指定内外层vector大小
    v.resize(n, vector<int>(m));
    

    定义一个二维整形数组并初始化:

    vector<vector<int> > array(m); //这个m一定不能少//vector<int> array[m];
    //初始化一个m*n的二维数组
    for(int i=0;i<m;i++) 
    {
        array[i].resize(n);
    }
    //遍历赋值
    for(i = 0; i < array.size(); i++)
    {
       for (j = 0; j < array[0].size();j++) 
        {   
            array[i][j] = (i+1)*(j+1); 
        } 
    }
    

    sort

    用法:

    1、sort函数可以三个参数也可以两个参数,必须的头文件#include < algorithm>;

    2、它使用的排序方法是类似于快排的方法,时间复杂度为n*log2(n)

    3、sort函数有三个参数:(第三个参数可不写)
    (1)第一个是要排序的数组的起始地址。
    (2)第二个是结束的地址(最后一位要排序的地址)
    (3)第三个参数是排序的方法,可以是降序也可是升序;还可以不写第三个参数,此时默认的是升序。

    两个参数:

    #include<iostream>
    #include<algorithm> 
    using namespace std;
     
    int main(){
    	int a[10]={1,3,5,2,14,6,7,62,9};
    	for(int i=0;i<10;i++){
    		sort(a,a+10);
    		for(i=0;i<10;i++){
    			cout<<a[i]<<" ";
    		}
    	}
    	system("pause");
    	return 0;
    	
    } 
    

    在这里插入图片描述

    三个参数:

    #include<iostream>
    #include<vector>
    #include<algorithm> 
    using namespace std;
     
    bool myfunction(int i,int j){
    	return (i<j);
    }//升序排列 
    bool myfunction2(int i,int j){
    	return (i>j);
    }//降序排列 
    struct myclass{
    	bool operator()(int i,int j){
    		return (i<j);
    	}
    }myobject; 
    
    int main(){
    	
    	int myints[8]={32,14,64,3,23,6,44,75};
    	vector<int> myvector(myints,myints+8);
    	
    	sort(myvector.begin(),myvector.begin()+4);
    	sort(myvector.begin()+4,myvector.end(),myfunction);
    	sort(myvector.begin(),myvector.end(),myobject);
    	
    	cout<<"myvector contains:";
    	for(vector<int>::iterator it=myvector.begin();it!=myvector.end();it++){
    		cout<<' '<<*it;
    	}
    	cout<<'\n';
    	
    	system("pause");
    	return 0;
    	
    } 
    

    在这里插入图片描述
    string使用反向迭代器来完成逆序排列(rbegin,rend)

    #include<iostream>
    using namespace std;
     
    int main(){
    	string str("abcdef");
    	string s(str.rbegin(),str.rend());
    	cout<<s<<endl;
    	 
    	return 0;
    	
    } 
    

    在这里插入图片描述
    转自博主 布林叮咚

    想要拷贝元素:for(auto x:range)

    想要修改元素 : for(auto &&x:range)

    想要只读元素:for(const auto &x:range)

    find

    find() 函数本质上是一个模板函数,用于在指定范围内查找和目标元素值相等的第一个元素。

    如下为 find() 函数的语法格式:
    InputIterator find (InputIterator first, InputIterator last, const T& val);

    其中,first 和 last 为输入迭代器,[first, last) 用于指定该函数的查找范围;val 为要查找的目标元素。

    展开全文
  • C/C++常用函数汇总

    千次阅读 多人点赞 2019-03-20 21:12:29
    汇总C/C++中常见的主流函数,适用于竞赛、笔试考前突击

    1 string.h、cstring(C)

    (1)字符串连接函数 strcat、strncat
    strcat(char[ ], const char[ ])
    strncat(char[ ], const char[ ], int )

    char str1[30]="People's Republic of ";
    char str2[]="China";
    strcat(str1,str2);
    cout<<str1<<endl; //People's Republic of China
    strncat(str2,"12345",2);
    cout<<str2; //China12
    

    (2)字符串复制函数 strcpy、strncpy
    strcpy(char[ ], const char[ ])
    strncpy(char[ ], const char[ ], int )

    char str1[10],str2[10],str3[]="China";
    strcpy(str1,str3);
    cout<<str1<<endl; //China
    strncpy(str2,str3,2);
    cout<<str2; //Ch
    

    (3)字符串比较函数 strcmp
    strcmp(const char[ ],const char[ ])

    strcmp(str1,str2);
    

    1)如果str1=str2, 函数值=0;
    2)如果str1>str2, 函数值>0;
    3)如果str1<str2, 函数值<0;
    (4)字符串长度函数strlen
    strlen(const char[ ])

    char str[10]="China";
    cout<<strlen(str);//5
    

    (5)初始化函数memset
    memset(char[ ], int ,int )

    char str[30];
    memset(str,'a',5);
    cout<<str; //aaaaa
    

    (6)字符串分割
    char *strtok(char src[], const char *delim)
    src为待分解的字符串,delim为分隔符
    由于C/C++没有 split() 函数,这里借用 strtok() 函数简单实现一下:

    int split(char *src,char *separator,char *dest[]) {
    	int i=0;
        char *p=strtok(src,separator);
        while(p!=NULL) {
            dest[i++]=p;
            p=strtok(NULL,separator);
        }
        return i;
    }
    

    2 cstring、string(C++)

    (1)复制、连接、比较运算

    string str1,str2,str3;
    str1="abc"; //复制,abc 
    cout<<str1<<endl; 
    str2=str1+"def"; //连接,abcdef
    cout<<str2<<endl;
    cout<<(str1>str2)<<endl; //比较,0
    cout<<(str1<str2)<<endl; //比较,1
    cout<<(str1=="abc");    //比较,1
    

    (2)查找子串函数find、rfind
    正向查找
    find(string )
    find(string ,int )

    string s="abcaabcddbc";
    cout<<s.find("abc")<<endl; //0
    cout<<s.find("bc")<<endl; //1
    cout<<s.find("ef")<<endl; //18446744073709551615(即-1)
    cout<<s.find("abc",1)<<endl; //4
    cout<<s.find("bc",6)<<endl; //9
    

    逆向查找
    find(string )

    string s="abcaabcddbc";
    cout<<s.rfind("abc")<<endl; //4
    cout<<s.rfind("bc")<<endl; //9
    cout<<s.rfind("ef")<<endl; //18446744073709551615(即-1)
    

    注意:在条件控制语句中,不要将find()的返回值与0或-1作大小比较,而应与-1作等于或不等于比较。

    string s="abcaabcddbc";
    //正确做法 
    cout<<(s.find("abc")!=-1)<<endl; //1
    cout<<(s.find("abc")==-1)<<endl; //0
    cout<<(s.find("ef")==-1)<<endl; //1 
    cout<<(s.find("ef")!=-1)<<endl; //0
    //错误做法 
    cout<<(s.find("abc")>-1)<<endl; //理论返回1,实际0
    cout<<(s.find("ef")<0)<<endl; //理论返回1,实际0
    

    (3)替换子串函数replace
    replace(int ,int ,string )

    string s="aaabbbccc";
    s.replace(3,3,"**");
    cout<<s; //aaa**ccc
    

    3 math.h、cmath

    (1)int abs(int i) //返回整型参数i的绝对值
    (2)double fabs(double x) //返回双精度参数x的绝对值
    (3)long labs(long n) //返回长整型参数n的绝对值

    (4)double exp(double x) //返回指数函数e^x的值
    (5)double pow(double x,double y) //返回x^y的值
    (6)double pow10(int p) //返回10^p的值

    (7)double log(double x) //返回logex的值
    (8)double log10(double x) //返回log10x的值

    (9)double sqrt(double x) //返回√x的值

    (10)int ceil(double x) //返回不小于x的最小整数
    (11)int floor(double x) //返回不大于x的最大整数

    4 stdlib.h、cstdlib

    (1)void exit(int code) //终止程序执行
    (2)void * malloc(long NumBytes) //申请内存
    (3)void free(void *ptr) //释放内存

    #include<cstdlib>
    using namespace std;
    int main(){
    	int *i=(int *)malloc(sizeof(int)); //开辟一个整型数据空间 
    	float *f=(float *)malloc(sizeof(float)*5); //开辟一个长度为5的浮点型数组
    	free(i); //释放整型数据空间 
    	free(f); //释放浮点型数组空间
    	
    	i=new int; //开辟一个整型数据空间
    	f=new float[5]; //开辟一个长度为5的浮点型数组
    	char *c=new char('a'); //开辟一个字符型数据空间,并赋初值为'a' 
    	c=(char *)new char[4][5]; //开辟一个4x5字符数组 
    	delete i;
    	delete f;
    	delete c;
    	return 0;
    }
    

    注意:new、delete、sizeof()都是运算符
    (4)void srand(int seed) //随机数生成器种子
    (5)int rand(void) //生成0~32768之间的一个随机数

    #include<iostream>
    #include<cstdlib>
    #include<ctime>
    using namespace std;
    int main(){
    	srand(time(NULL));
    	cout<<rand();
    	return 0;
    } 
    

    5 algorithm

    (1)排序函数sort
    升序:sort(begin, end, less())
    降序:sort(begin, end, greater())

    #include<iostream>
    #include<string>
    #include<algorithm>
    using namespace std;
    int main(){
    	int i;
    	int a[]={8,4,1,0,6,3,5,7,9,2};
    	int b[]={8,4,1,0,6,3,5,7,9,2};
    	float f[]={8.1,4.1,1.1,0.1,6.1,3.1,5.1,7.1,9.1,2.1};
    	char c[]="iebagdfhjc";
    	string s[]={"wan","bi","zhang","ding","li"};
    	
    	sort(a,a+10); //升序排序(整数) 
    	sort(b,b+10,greater<int>()); //降序排序(整数)
    	sort(f,f+10); //升序排序(浮点数)
    	sort(c,c+10); //升序排序(字符)
    	sort(s,s+5); //升序排序(字符串)
    	
    	for(i=0;i<10;i++)
    		cout<<a[i]<<" ";
    	cout<<endl;
    	for(i=0;i<10;i++)
    		cout<<b[i]<<" ";
    	cout<<endl;
    	for(i=0;i<10;i++)
    		cout<<f[i]<<" ";
    	cout<<endl;
    	for(i=0;i<10;i++)
    		cout<<c[i]<<" ";
    	cout<<endl;
    	for(i=0;i<5;i++)
    		cout<<s[i]<<" ";
    	return 0;
    }
    

    在这里插入图片描述

    6 文件操作

    (1)stdio.h、cstdio(C)

    #include<stdio.h>
    int main(){
    	int i,a[5];
    	FILE *fp;
    	fp=fopen("in.txt","r");
    	for(i=0;i<5;i++){
    		fscanf(fp,"%d",&a[i]);
    	}
    	fclose(fp);
    	fp=fopen("out.txt","w");
    	for(i=0;i<5;i++){
    		fprintf(fp,"%d ",a[i]);
    	}
    	fclose(fp);
    	return 0;
    } 
    

    (2)fstream(C++)

    #include<fstream> 
    using namespace std;
    int main(){
    	int i,a[5];
    	ifstream in("in.txt"); //文件输入流 
    	for(i=0;i<5;i++){
    		in>>a[i];
    	}
    	in.close();
    	ofstream out("out.txt"); //文件输出流 
    	for(i=0;i<5;i++){
    		out<<a[i]<<" ";
    	}
    	out.close();
    	return 0;
    }
    
    展开全文
  • C++函数详解

    千次阅读 多人点赞 2021-05-14 00:19:08
    c++函数 1、函数的概念 什么是函数 在《C++Primer》中对于函数这样说道: 函数是一个命名了的代码块,我们通过调用函数执行相应的代码,函数可以有0个或者多个参数,而且会产生一个结果 对于我的总结: 我觉得函数...

    c++函数

    1、函数的概念

    什么是函数

    在《C++Primer》中对于函数这样说道:

    函数是一个命名了的代码块,我们通过调用函数执行相应的代码,函数可以有0个或者多个参数,而且会产生一个结果

    对于我的总结:

    我觉得函数可以说是一个能够实现一定功能的盒子,把他需要的工具放进去,他给你返回一个结果,可以说函数的内部是一个未知的东西,我们只需要知道这个函数能实现什么样的功能就行了,不需要去知道里面的代码怎么写的。

    为什么使用函数

    当一个项目或者代码全部紧挨在一起的话,会显得开发十分繁杂,比如一个源文件的main函数中写了很多的代码,前20行实现一个功能,接下来100行实现另一个功能,再300行又实现一个功能…,这样下去,在一个main函数中零零散散地实现了很多功能!但是,过几天反过来再来看源代码,感觉就是脑袋一翁,一个main函数里面写了好几百行代码,不知道这些东西是什么,这样的开发会造成效率的丧失,会让我们没有思路,所以将一个个功能用一个个的函数封装起来,并做好注释,会节省我们很多的开发时间,使得代码可读性,容错性都会大大提高,所以一个良好的使用函数和注释的习惯是一个程序员必备(可以这么说)的品质

    2、函数基础

    一个函数由以下部分组成

    返回类型+函数名(参数列表){代码块}

    ​ 比如一个代码,求两个数的和并输出

    #include<iostream>
    
    int main(){
        int a,b;
        std::cin>>a>>b; //输入两个数的值
        int count = a+b;//count为a+b之后的值
        std::cout<<"两数之和为:"<<count<<'\n'; //输出计算得到的值
        return 0;
    }
    

    在上面的代码中,再main函数中定义了一个求两数之和的程序,所有的计算代码都在main函数里面,下面我们对其加法功能进行一个封装

    #include<iostream>
    
    void addData(int a,int b){  
        int count = a+b;//count为a+b之后的值
        std::cout<<"两数之和为:"<<count<<'\n'; //输出计算得到的值
    }
    
    int main(){
        int a,b;
        std::cin>>a>>b; //输入两个数的值
        addData(a,b); 
        return 0;
    }
    

    我们将求和并输出的代码封装到了一个函数addData中,可以说addData就是实现一个两数相加并输出的功能,对于之后还需要进行两数相加的操作,我们不需要重复地写相加输出代码,只需要调用addData即可,这样不仅提高了代码的可读性,将不同功能进行了区分,而且减少了代码的重复书写,对于一些经常要用到的代码操作,使用函数将这个功能封装起来是一个很好的方法!

    3、形参和实参

    在函数的编写格式中,在函数名的后面的括号里放入的参数是形式参数

    返回类型+函数名(形参列表){…}

    上面的代码中,在int addData(int a,int b)里面,这里面的a,b是一个形式参数,可以这么理解,现在这些参数a,b的具体值我不知道。我只知道他是一个整型变量,当在运行函数调用时,传入的才是实际参数,比如main函数中的addData(a,b),此时的a,b是我们输入的已经初始化了的函数,将实际参数放入函数的过程叫做传递参数,即传递具体的值给函数的形式参数,进行特定的操作,它就类似于一个公式一样,你必须给定实际的值,才能得到实际的结果,在传递参数的过程中需要注意几点

    • 传入的实际参数必须跟形式参数的类型一样
    • 传入的实际参数必须是按照顺序传递的
    • 传入的实际参数的数量必须与形式参数的数量相同
    //比如前面的addData
    addData(3,2); //正确--传递的数量正确
    addData(3.0,2); //正确--3.0会强制转换为int类型
    addData("321");//错误--传递的类型不正确
    addData(2,3,1);//错误--传递的参数数量不对
    

    参数的定义

    • 每一个形参之间必须用逗号隔开,并注明类型
    • 可以不定义形式参数
    • 形式参数可以是任何基本类型或者本身定义的类型,可以是指针,引用,值
    int fun();//正确--隐式的定义无形式参数
    int fun(void);//正确--显示的定义无形式参数
    int fun(int a,b);//错误--每一个形式参数前都要有一个变量类型
    int fun(int a int b);//错误--不同的形式参数之间没有用逗号隔开
    int fun(int a,int b);//正确--值传递
    int fun(int *a,int *b);//正确--指针传递
    int fun(int &a,int &b);//正确--引用传递
    

    4、函数的调用

    直接调用

    直接调用即在代码中调用函数,比如说addData()

    嵌套调用

    嵌套调用指的是,举一个例子,在a函数中会调用b函数,而在b函数中又调用了a函数

    调用
    调用
    a
    b

    递归调用

    递归调用指的是函数内部调用函数自己

    调用
    a

    5、函数的参数传递

    C++函数的传递个人感觉是一个十分骚气的操作,他的值传递不像Java这么简单,如果不了解c++的传值类型,可能有一些方法的调用得到的结果往往不是我们所想的那样

    比如设计一个函数

    //交换两个变量的值
    void swaps(int a,int b){
     int temp = a;
     a = b;
     b = temp;
    }
    

    你写了一个函数,能够交换两个变量的值,于是在main函数中测试这个函数,却发现输出的结果往往不是我们想象的那样,发现值并没有交换,于是焦头烂额,我这思路没错啊…,到底错在哪里呢,其实是因为c++函数的传值的差异,如果读者有兴趣的话,不妨听我来讲一讲这其中的原因!

    int main(){
    	int a,b;
     cin>>a>>b;
     cout<<"a的值为:"<<a<<endl;
     cout<<"b的值为:"<<b<<endl;
     swaps(a,b);
     cout<<"a的值为:"<<a<<endl;
     cout<<"b的值为:"<<b<<endl;
     return 0;
    }
    

    1、值传递

    可以知道,每一个变量的定义都会在内存中对应一个地址,每一个地址是对应着特定的编号的,值即这个对应内存地址里面存储的数据,将作为形式参数传入数组,比如上面main函数的swab(a,b),你以为swap里面用到的a,b就是main函数里面定义的a,b,但是实际不是这样的,可以对函数做一些修改,打印出他的内存地址

    void swaps(int a,int b){
     cout<<"Function Swap address_a is"<<&a<<endl;
     cout<<"Function Swap address_b is"<<&b<<endl;
     int temp = a;
     a = b;
     b = temp;
    }
    
    int main(){
    	int a,b;
     cin>>a>>b;
     cout<<"Address_a"<<&a<<endl;
     cout<<"Address_b"<<&b<<endl;
     cout<<"a:"<<a<<endl;
     cout<<"b:"<<b<<endl;
     swaps(a,b);
     cout<<"a:"<<a<<endl;
     cout<<"b:"<<b<<endl;
     return 0;
    }
    

    在这里插入图片描述

    可以看到,运行结果根本没有交换a,b的值,因为在swap里面的a和b与在mian函数里面输入的a和b地址都不一样,根本就不是同一个变量!所以这样的交换数据的函数根本不是一个可以成功交换的函数,他其实是重新定义了两个int类型变量,只是值与a和b相等,所以值传递并不能达到修改变量的作用

    可以看到当我们在调用函数时传入参数,但是不想改变(非本愿)传入的变量的值时,我们可以采用值传递的形参定义方式

    2、指针传递

    相比较于值传递,指针传递又是另外一个方法,指针变量指向的是这个变量存储的内存位置,即指针变量指向内存地址,这个指针变量存储在另一个内存中,通过这个指针,我们可以修改这个指针指向的地址位置的变量数值,对于上面的两数交换的数据,我们就可以用指针传递的形式达到交换两个数据的效果

    修改代码如下

    #include<iostream>
    using namespace std;
    void swaps(int *p,int *q){
    	cout<<"Function swaps Point p Address:"<<&p<<endl;
     cout<<"Function swaps Point q Address:"<<&q<<endl;
     int temp = *p;
     *p = *q;
     *q = temp;
    }
    
    int main(){
     int a,b;
     cin>>a>>b;
     int *p=&a,*q=&b;
     cout<<"Point p Address:"<<&p<<endl;
     cout<<"Point q Address:"<<&q<<endl;
     cout<<"a:"<<a<<endl;
     cout<<"b:"<<b<<endl;
     swaps(p,q);
     cout<<"a:"<<a<<endl;
     cout<<"b:"<<b<<endl;
    
    }
    

    在这里插入图片描述

    从运行结果可以看到,达到了一个交换的效果,以指针的形式,但是可以看到传入的指针跟mian函数里面定义的指针也是不一样的!其实指针传递可以理解为另类的值传递,传递的指针参数也是一个变量类型,在这种swap函数的修改其实是对指针变量指向的内存地址里面的值进行修改,即main函数里面变量a和b的地址里面的值进行修改,也就可以理解为修改了a和b里面的值,这里可以用一张图表明
    在这里插入图片描述

    3、引用传递

    引用传递其实是跟地址传递具有相同的效果,但是,唯一的区别是引用变量一旦定义,里面的指向的地址位置是不能修改的,相当于*const p

    代码实现

    #include<iostream>
    using namespace std;
    void swaps(int &p,int &q){
    	cout<<"Function swaps a Address:"<<&p<<endl;
     cout<<"Function swaps b Address:"<<&q<<endl;
     int temp = *p;
     *p = *q;
     *q = temp;
    }
    
    int main(){
     int a,b;
     cin>>a>>b;
     cout<<"a Address:"<<&a<<endl;
     cout<<"b Address:"<<&b<<endl;
     cout<<"a:"<<a<<endl;
     cout<<"b:"<<b<<endl;
     swaps(a,b);
     cout<<"a:"<<a<<endl;
     cout<<"b:"<<b<<endl;
    
    }
    

    在这里插入图片描述

    可以看到引用变量传入的值就是mian函数里面的a和b,地址是一样的

    4、数组传递

    一维数组

    数组的传递其实就是指针的传递,当然在C++的STL中有一个可以代替数组的更安全的类型array(这里不考虑),对于c++中的数组类型,其实就是一个指针类型,比如说定义一个数组int a[],这里a就是指向a[0]的指针,要获得a[1],只需要a++即可

    移动
    移动
    a
    b
    c
    d
    e
    f
    指针p
    指针p
    指针p
    //打印数组
    void prints1(int a[],int len){
     for(int i=0,i<len;i++){
         printf("%d\t",a[i]);
     }
     printf("\n");
    }
    
    void prints2(int *a,int len){
     for(int i=0,i<len;i++){
         printf("%d\t",*a);
         a++;
     }
     printf("\n");
    }
    //这两个方法感觉都是指针传递,因为他们都能修改传入的原数组的值
    
    int main(){
     int a[3] = {1,2,3};
     prints1(a,3);
     prints2(a,3);
     return 0;
    }
    
    

    在这里插入图片描述

    可以看到***a和a[]**其实没有区别

    二维数组

    二位数组其实也没啥,也就是按照一维数组的思想,但是人为的规定了一些限制,因为二维数组数据在内存中是顺序条状存储的,即从1到n个连续的内存位置,存储的是二位数组,计算机才不会管你的几行几列,它只知道只有顺序存储链式存储之所以有二位数组,是人为的规定了,比如1到多少个内存位置是第一行…,既然这样,同样可以用一个*p来访问二位数组 ,于此同时也可以用双指针(或者说行指针)来访问二位数组

    采用一维指针的方式访问

    void PrintDoubleArray(int *p,int row,int lie){
    	for(int i = 0;i<row;i++){
      for(int j = 0;j<lie;j++){
          printf("%d\t",*p);
          p++;
    		}
      printf("\n");
    }
    }
    

    采用二维数组的形式访问

    void PrintDoubleArray1(int p[][3],int row,int lie){
    for(int i=0;i<row;i++){
      for(int j=0;j<lie;j++){
          printf("%d\t",p[i][j]);
      }
      printf("\n");
    }
    }
    

    采用行指针的形式访问

    void PrintDoubleArray2(int (*p)[3],int row,int lie){
    for(int i=0;i<row;i++){
      for(int j=0;j<lie;j++){
          printf("%d\t",*((*p+i)+j));
      }
      printf("\n");
    }
    }
    

    这三个方法都能够打印出二维数组,但是他们的定义放方式不同

    • 一个是采用以为数组,即把二维数组当作一个长一点的一维数组,用指针往后自增来遍历二维数组中的每一个元素
    • 另一个是采用索引的方法a[i][j]的形式,来访问二位数组中的每一个元素,但是形式参数的第二个[]里面必须有一个常数,即你传入的二维数组的列数必须是跟形式参数一样的,否则无法传递
    • 第三个是以行指针的形式,他的访问方式如下
    分类表示方法备注
    行指针p+i, *p[i]下标为第i行的指针
    元素指针*(p+i)+j, p[i]+j第i行第j列的元素指针
    元素*(*(p+i)+j), *(p[i]+j)第i行第j列的元素

    测试代码,分别用上面三种传值方法输出二维数组

    int main(){
        int a[][3]={{1,2,3},{2,3,4},{3,2,5},{1,5,1}};
        int *p = &a[0][0];
        PrintDoubleArray(p,4, 3);
        cout<<endl;
        PrintDoubleArray1(a,4,3);
        cout<<endl;
        PrintDoubleArray2(a,4,3);
        return 0;
     }
    

    在这里插入图片描述

    可以看到得到的结果是一样的

    5、为参数默认值

    在函数中,除了传递变量之外,还可以为设置的形式参数设置默认值,当一个参数具有默认值时,调用其时可以不需要传入该形式参数

    比如一个函数中的某些参数,我们没有传入时,他是他执行默认的方法,比如一个时间显示器,我们需要传入的参数为时区,当我们没有传入时区时,默认的为北京时间,就显示一个北京时间

    void showTime(int opt = 1){
     switch(opt){
         case 1:{
             cout<<"BeJing time:"<<"xxxx.xx.xx.xx\n";
             break;
         }
         case 2:{
             cout<<"NewYork time:"<<"xxxx.xx.xx.xx\n";
             break;
         }
     }
    }
    

    然后测试一下

    int main(){
     int des = 2;
    	showTime();
     showTime(des);
     return 0;
    }
    

    结果:

    在这里插入图片描述

    可以看到,当没有传入参数时,这个方法将调用形式参数opt的默认值1进行处理,否则按照传入参数进行处理

    6、函数的重载

    函数的重载的意思即为相同的函数名实现不同的功能,一个相同的函数名他的参数数量,返回类型又可以不同,用来实现其他的功能

    比如我们设计一个比较两个变量的大小的函数,可看到

    bool compare(int a,int b){
     return a>b;
    }
    bool compare(double a,double b){
    	return a>b;
    }
    bool compare(float a,float b){
     return a>b;
    }
    

    可以看到,函数名是相同的,但是参数的类型是不同的,他们都实现了一个比较的函数,为了简化上面的代码,我们可以用函数模板来写这个函数,函数模板会在后面介绍,再打个比方,一个物体是有面积的,但是对于不同的物体,传入的参数和求面积的方式是不同的

    void area(int r){//求圆的面积
     cout<<"The area of Circle is:"<<3.14*r*r;
    }
    void area(int a,int b){//求矩形的面积
     cout<<"The area of Rectangle is:"<<a*b;
    }
    

    可以看到上面的函数定义中,一个area函数能有不同的求面积的方法,参数的数量和类型可以不同,即相同的函数名可以实现很多的方法

    7、函数模板

    对于上面的compare函数,要实现不同的比较方法,需要重新写很多份代码,这样大大加大了代码的冗余度,为了解决这个问题,其实c++是有一个函数模板编程方法的,即起始我们不知道这个形式参数的具体类型是什么,而是在程序运行的时候将特定的变量代替这个模型,定义的格式为

    template<typename T> //T是一个起初未知的模板类型
    bool compare(T a,T b){
     return a>b;
    }
    

    我们并不知道T的具体类型是什么样子的,但是这样的话可以大大地减少代码的冗余度,这个变量类型T只有在实际的编译运行过程中根据用户的输入变量类型来替代,但是T不能是所有的变量类型,它也是有限制的,是根据代码来确定适配范围的,如果一个类型没有重载>这个运算符,这种类型传入无法比较大小,这是程序运行的过程中是会报错的

    8、内联函数和constexpr函数

    内联函数

    在程序的运行中,一次函数的调用远非我们想象的只是执行几行语句那么简单,假设有这么一个函数

    string& shortString(const string &st1,const string &st2){
     return st1.size()>st2.size()?st2:st1;
    }
    //这个函数的意思即为返回两个字符串中长度较小的字符串的引用类型
    

    在shortString函数执行的过程中,并不是简单的return st1.size()>st2.size()?st2:st1;在执行这句话之前,还有着一系列的操作,比如将方法入口拷贝到寄存器,并且在返回时恢复,或者需要拷贝实参,返回返回值…,需要经历一系列的操作之后,上面那一句话只是这一系列操作的一部分,那么对于这些十分简单的函数语句描述,可以用内联函数来实现,内联函数能够避免函数调用的额外开销,将函数指定为内联函数,通常是在每个调用点的内联地址展开,而无需前面的这么多步操作

    定义内联函数十分简单,只需要在返回值前面加一个inline即可,上面的方法改为内联为

    inline string& shortString(const string &st1,const string &st2){
        return st1.size()>st2.size()?st2:st1;
    }
    
    cout<<shortString(st1,st2)<<endl;
    //其实在编译的的过程中变相的执行了
    cout<<(st1.size()>st2.size()?st2:st1)<<endl;
    

    需要注意的是

    • 内联函数只是一个声明,至于在编译的过程中编译器是否把这个函数当作内联函数还得看编译器的想法,即有时候我们可能觉得这个函数是内联函数,但是编译器在编译的过程中并不这样认为
    • 内联机制只适用于语句少,代码体简单的函数,如果函数比较复杂的话,inline就没有作用了

    constexpr函数

    constexpr函数是指能用于常量表达式的函数,即返回值可以是字面值常量,使用constexpr需要注意

    • 返回值和形式参数都必须是字面值类型
    • 函数体中有且只有一条return语句
    constexpr int new_fun(){return 42;} //一个constexpr函数
    constexpr int foo = new_fun(); //一个正确的常量表达式
    

    9、函数的指针

    函数指针也是函数调用中的一个方法,可以把函数想象成一个变量,那么对于函数也可以存在指针,函数指针指向某种特定的类型,函数的类型由他的返回值和形参类型共同决定,与函数名无关

    定义函数指针

    返回类型 (*指针名)(形参列表); //函数指针的定义
    //比如对于前面定义的函数shortStirng
    string& (*st)(const string &st1,const string& st2);//未初始化
    

    初始化函数指针

    st = shortString; //st指向名为shortString的函数
    st = &shortString; //等价赋值语句:取地址符可选
    

    使用函数指针

    string s1 = st("abc","defs"); //调用shortString函数
    string s2 = (*st)("abc","defs");//等价的调用
    string s3 = shortString("abc","defs");
    

    定义的函数指针必须指向返回类型和形参类型和数量相同的函数,当函数指针为空时可以给他定义为nullptr或者0

    string::size_type sunLength(const string &,const string &);
    bool cstringCompare(const char *,const char*);
    pf = nullptr; //空指针
    pf = 0; //也是空指针的意思
    pf = sunLength;//错误--返回类型不同
    pf = cstringCompare; //错误--参数类型不匹配
    

    函数和函数指针可以作为函数中的形式参数

    函数和函数指针和数组有些类似,可以作为函数的形式参数

    void funa(const string *st1,const string &st2,string& st(const string &,const string &)); //函数类型作为形参
    void funb(const string *st1,const string &st2,string& (*st)(const string &,const string &));//函数指针类型作为形参,当以函数指针作为形参时,可以直接将函数名作为实参使用,编译器会将这个实参转换为函数指针类型
    
    funb("abe","sdass",shortString);
    

    用typedef和decltype用特定的名字代替函数指针和函数名

    void a(){
        
    }
    //testfun1和testfun2都是函数类型
    typedef bool testfun1();
    typedef decltype(a) testfun2;
    //testfun3和testfun4都是函数指针类型
    typedef bool (*testfun3)();
    typedef decltype(a) *testfun4;
    
    //以函数指针作为形式参数
    //等价的传值
    void funa(testfun1); //testfun1 == bool testfun1()
    void funb(testfun2); //testfun2 == void a()
    void func(testfun3); //testfun3 == bool (*testfun3)()
    void fund(testfun4); //testfun4 == void (*testfun4)() 即a函数的指针类型
    

    返回指向函数的指针

    using F = int (int*,int); //F是一个函数类型
    using PF = int(*)(int*,int);//F是一个指针类型
    PF f1();//正确--返回类型为PF指针的函数
    F f2();//错误--函数不能返回一个函数,只能返回函数的指针
    F *f3();//正确
    
    展开全文
  • C++函数指针用法

    千次阅读 2022-01-06 00:25:41
    C++函数指针详细理解 函数指针初识 函数指针是指向函数的指针,并不等于函数,它能够执行函数的操作,可以跟指针变量一起来理解,其基本声明格式为: type (*ptrname)(形参列表); 例子,声明一个比较两个字符串大小的...
  • C++函数定义

    千次阅读 2021-04-22 15:09:38
    C++函数定义前言1、函数的概念2、函数的定义3、函数的调用4、函数的分文件编写 前言 学习黑马程序员关于C++的笔记 1、函数的概念 作用:将一段经常使用的代码进行封装,减少重复代码,增加代码利用。 2、函数的定义 ...
  • C++函数数组

    千次阅读 2019-01-25 14:21:03
    在日常编码过程中,我们经常使用到数组,以C++的基本数据类型作为存储对象,而在某些特殊的情况下,我们需要使用到函数数组或函数指针(譬如回调函数),其实质为一个指针数组,数组内存储着各个函数的指针地址,在...
  • C++函数指针详解

    千次阅读 2020-02-05 17:26:09
    详细讲解函数指针的作用,声明,赋值,使用,附有代码。
  • C++函数返回值

    千次阅读 多人点赞 2020-03-12 19:03:15
    首先,强调一点,和函数传参一样,函数返回时也会做一个拷贝。从某种角度上看,和传参一样,也分为三种: 一般(传统)返回:返回任意类型的数据类型,会有一个拷贝,对于复杂对象效率低下;例如:int test(){}或者...
  • c++函数指针和函数对象

    千次阅读 2019-04-07 17:29:05
    C++ 函数指针和函数类型一、 导述二、c++成员函数在内存中的存储方式新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个...
  • C++函数指针(函数作为参数)

    千次阅读 2020-02-19 18:27:34
    所指函数的返回类型 + 指针名 + 所指函数的参数列表 double (*pf)(int);// 指针pf指向的函数, 输入参数为int,返回值为double const vector<int>* (*seq_ptr)(int);// 指针seq_ptr指向一个vector类型的指针 ...
  • c++函数调用数组

    千次阅读 2021-03-31 14:10:16
    int fun(int a[3][2]) { } int main() { fun(a); }
  • c++ 函数指针

    万次阅读 多人点赞 2019-06-15 21:41:38
    函数指针基础: 1. 获取函数的地址 2. 声明一个函数指针 3.使用函数指针来调用函数 获取函数指针: 函数的地址就是函数名,要将函数作为参数进行传递,必须传递函数名。 声明函数指针 声明指针时,必须指定...
  • C++函数指针、指针函数、返回值为函数指针的函数浅谈 引言 函数指针、指针函数是C中重要而容易混淆的概念,博主将通过两个实例来说明这两个截然不同的概念。 而返回值为函数指针的指针函数就更难理解了,放在文章的...
  • C++函数模板和模板函数的区别

    千次阅读 2020-09-02 09:44:52
    为进一步简化,C++提供了函数模板,实际上是建立一个通用函数,其函数类型和形参类型不具体指定,用一个虚拟的类型来代表,此通用函数即为函数模板。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型,从而...
  • c++ 构造函数详解

    万次阅读 多人点赞 2019-05-31 17:20:58
    c++构造函数详解。(构造函数的分类、拷贝构造函数
  • C++函数前后加const

    千次阅读 多人点赞 2019-04-22 15:17:01
    const更大的魅力是它可以修饰函数的参数、返回值,甚至函数的定义体。 函数前面的const: 返回值为const; 函数后面的const: const函数; const的函数不能对其数据成员进行修改操作。 const的对象,不能引用非...
  • 函数符号(函数的名字修饰):在编译阶段生成的字符串,来指明函数的定义或原型 。 C函数符号生成规则: _cdel调用约定(C标准调用约定):函数名前加下划线。...C++函数符号生成规则: _cdecl调用约...
  • C中如何调用C++函数?

    千次阅读 2020-04-09 09:00:34
    我在学习RT-Thread的时候使用了一些C++包,在以C语言的主函数中调用总是找不到C++相关函数,添加头文件等C语言的调用函数处理方式在调用C++函数时似乎不能正常编译。于是看到这篇文章,简短扼要、非常有效。
  • c++函数参数默认值设置

    千次阅读 2020-09-08 14:03:46
    c++函数参数默认值设置 1,函数参数默认值在函数声明的参数列表上定义,函数定义不变; #include <iostream> using namespace std; int add(int a = 0, int b = 0, int c = 0); int main() { std::cout <...
  • c++返回函数指针的函数

    千次阅读 2021-07-17 20:43:05
    返回函数指针的函数函数指针指针函数返回函数指针的函数 函数指针 类似于数组名,在C语言中函数名的实际就是函数所在空间的首地址,故也可声明相应类型的函数指针用于指向相应的实际函数,更深层次甚至可以声明...
  • c++ 函数声明与定义

    千次阅读 2021-05-29 19:56:23
    为什么 C++ 允许多次声明呢
  • c++函数const

    千次阅读 2018-12-05 11:46:48
    一个对象通过引用的方式传到函数f中,而函数f又不会通过修改对象的数据成员的值改变该对象的状态,那么最好将f的参数标记为const,如void setName( const string&amp;amp; n){ name = n;} 如果一个成员函数不...
  • c++函数重载和重写

    千次阅读 2020-07-17 10:43:33
    C++的这种编程机制给编程者极大的方便,不需要为功能相似、参数不同的函数选用不同的函数名,也增强了程序的可读性。 举例 (1) void func1( int arg1); (2) void func1( double arg1); (3) void func1( int ...
  • C/C++ 函数指针

    千次阅读 多人点赞 2018-06-02 17:01:19
    一、定义 函数指针是指向函数的指针变量。 因此“函数指针”本身首先应是指针变量,只不过该指针变量指向函数。扩展:函数指针和指针函数的区别? 他们只是名字比较像。函数指针是指向函数的指针变量,本质是一个...
  • C++ 构造函数详解

    千次阅读 2021-06-06 11:11:53
    C++中各类构造函数说明,含有样例。
  • C++函数详解

    千次阅读 多人点赞 2021-05-26 10:25:43
    在实现c++多态时会用到虚函数。虚函数使用的其核心目的是通过基类访问派生类定义的函数。所谓虚函数就是在基类定义一个未实现的函数名,为了提高程序的可读性,建议后代中虚函数都加上virtual关键字。一般格式: ...
  • C++ 函数返回数组处理方法

    千次阅读 2020-12-22 14:31:24
    首先C++函数的返回类型没有“数组”这一结构,因此一般情况下我们会采用指针去接受数组的首地址来进行返回。另外由于函数体内定义的变量均为局部变量,局部变量被存储在栈区会在函数调用完毕之后被系统回收,因此,...
  • c++函数的基本使用

    千次阅读 多人点赞 2018-12-10 11:11:53
    函数 ...1.一个程序有且只有一个main()函数c++从main()函数开始执行,在main()函数结束。 2.c++语言中,所有函数都是平行独立的,无主次、相 互包含之分。函数可以嵌套调用,不可嵌套定义。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,593,761
精华内容 637,504
关键字:

c++函数大全

c++ 订阅