c++各种函数传参(超级详细)

前言:作者一开始也不是很清楚函数传参的各种类型,(只会int),但后来发现这时远远不够的,所以下面给大家讲解一下各种类型的传参,包含指针,单反知道电脑是个啥的都能听懂

一.int类型:

#include<bits/stdc++.h>
using namespace std;
void c_out(int b){
	cout<<b;
}
int main(){
	int a=2;
	c_out(a);
	return 0;
}

首先先来看一段最简单的代码,这里创建了一个叫做c_out的函数,把一个int类型的变量a传给了函数,这里c_out(a)传入的是实参,void c_out(int a)是形参,也就是把a的值复制一份给函数,可以理解为 int b=a,因为这里是复制,所以再函数里面无论干什么,就算你大闹天宫,都不会影响main函数里的a的数值

#include<bits/stdc++.h>
using namespace std;
int a=2;
void c_out(){
	cout<<a<<endl;
	a=3;
	cout<<a;
}
int main(){
	c_out();
	return 0;
}

输出:2

这里的话 ,我们定义了一个全局变量,也就适用于c_out和main里面了,所以无论是c_out里还是main里修改变量a都是有效的

#include<bits/stdc++.h>
using namespace std;
void swap(int &a,int &b){
	int c=a;
	a=b;
	b=c;
}
int main(){
	int a=1,b=2;
	swap(a,b);
	cout<<a<<' '<<b;
	return 0;
}

输出:2 1 

这里为什么就把a和b的值换了呢?我们可以这么理解:这个传参可以理解为:

int &a=a;

int &b=b; 

我们可以这么理解。这个&的意思就是应用,比如说:

int a=1;
int &b=a;

意思是说b引用a,也就是说是这个变量a的别名,无论是对a操作还是对b操作都是一个意思,那么既然是这样,我们swap里引用呢a和b变量,那么在swap里操作和在main操作里是一个意思。

#include<bits/stdc++.h>
using namespace std;
void swap(int *a,int *b){
	int c=*a;
	*a=*b;
	*b=c;
}
int main(){
	int a=1,b=2;
	swap(&a,&b);
	cout<<a<<' '<<b;
	return 0;
}

输出:2 1  

这里为什么也把数的值给换了呢?

因为我们给进去的是指针,我们还是可以先把形参和实参这么理解:

int *a=&a;

int *b=&b; 

这里也就是定义了两个指针,并且分别指向a和b的地址,也就是把a和b的地址传进了swap函数里,因为我们知道计算机的内存里的地址存放的是变量的值,也可以理解为你的两个同学A和B,你都知道了他们家的地址,你就可以通过他们的地址找到他们。这里也一样,我们可以通过地址来改变他们的值。

这里我们通过再定义一个c来中转,这里说明一下,在swap函数里:

cout<<a;出来的是main里的a的地址

cout<<*a;出来的是main里a的值 

二.int类型的数组 

#include<bits/stdc++.h>
using namespace std;
void f(int a[],int b[]){
	cout<<a[0]<<' '<<b[0];
}
int main(){
	int a[2]={1,2},b[2]={3,4};
	f(a,b);
	return 0;
}

输出:1 3 

这里我们向f函数里传入呢两个int类型的数组,这个就是标准的传入数组的方式,注意如果要把数组的长度传进去,要专门进行传入:

#include<bits/stdc++.h>
using namespace std;
void f(int a[],int b[],int lena,int lenb){
	cout<<a[0]<<' '<<b[0];
}
int main(){
	int a[2]={1,2},b[2]={3,4};
	f(a,b,2,2);
	return 0;
}//正确
#include<bits/stdc++.h>
using namespace std;
void f(int a[],int b[]){
	cout<<a[0]<<' '<<b[0];
}
int main(){
	int a[2]={1,2},b[2]={3,4};
	f(a[2],b[2]);
	return 0;
}//错误

那么数组可以用指针吗?答案是可以:

#include<bits/stdc++.h>
using namespace std;
void f(int *a,int *b){
	cout<<*a<<' '<<*b;
}
int main(){
	int a[2]={1,2},b[2]={3,4};
	f(&a[0],&b[0]);
	return 0;
}

输出:1 3 

我们来分析一下:这里传进了数组a和b的首元素的地址,我们在f里接受了a和b的地址后,我们通过*将对应地址的值输出,这样是没问题的。

下面问大家一个问题,我们这样子传入,可以在f里使用如下代码吗:

cout<<*a[1];

cout<<*b[1];

答案是:不能

为什么呢?我们来分析一下:我们既然已经使用了指针,也就是地址,那么就要一直使用到底:

#include<bits/stdc++.h>
using namespace std;
void f(int *a,int *b){
	cout<<*(a+1)<<' '<<*(b+1);
}
int main(){
	int a[2]={1,2},b[2]={3,4};
	f(&a[0],&b[0]);
	return 0;
}

输出:2 4 

这里的*(a+1)的意思就是在a的地址上加上一个int类型大小的值,因为我们知道数组是保存在连续的内存里的,那么这时候我们就定位到了a[1]这个值的地址,最后是用*来输出这个地址的值 

#include<bits/stdc++.h>
using namespace std;
void f(int &a,int &b){
	cout<<(a+1)<<' '<<(b+1);
}
int main(){
	int a[2]={1,2},b[2]={3,4};
	f(a[0],b[0]);
	return 0;
}

我们还有一种方式,就是引用,和上面的int类型的引用一样,不加赘述

三.char 

#include<bits/stdc++.h>
using namespace std;
void f(char a,char b){
	cout<<a<<b;
}
int main(){
	char a='a',b='b';
	f(a,b);
	return 0;
}

输出:ab 

不使用指针的情况下和int类型一样,传入形参。 

#include<bits/stdc++.h>
using namespace std;
void swap(char* a,char* b){
	char c=*a;
	*a=*b;
	*b=c;
}
int main(){
	char a='a',b='b';
	swap(&a,&b);
	cout<<a<<' '<<b;
	return 0;
}

输出:b a 

这里使用指针,也可以将a和b的值进行交换,和int类型一样

#include<bits/stdc++.h>
using namespace std;
void swap(char& a,char& b){
	char c=a;
	a=b;
	b=c;
}
int main(){
	char a='a',b='b';
	swap(a,b);
	cout<<a<<' '<<b;
	return 0;
}

输出:b a  

这个引用也是和int一毛一样 

三.字符串 

 不知道大家用的是c还是c++所以char[]和string都讲

1.char[]:

#include<bits/stdc++.h>
using namespace std;
void f(char a[]){
	cout<<a;
}
int main(){
	char a[]="abc";
	f(a);
	return 0;
}

输出:abc 

和int类型的数组也是一样的

接下来是指针:

#include<bits/stdc++.h>
using namespace std;
void f(char *a){
	cout<<*(a)<<*(a+1)<<*(a+2);
}
int main(){
	char a[]="abc";
	f(&a[0]);
	return 0;
}

接下来是引用:

#include<bits/stdc++.h>
using namespace std;
void f(char &a){
	cout<<(char)a<<(char)(a+1)<<(char)(a+2);
}
int main(){
	char a[]="abc";
	f(a[0]);
	return 0;
}

输出:abc 

注意这里要强制类型转换,要不然输出:

输出:a9899 

2.string 

#include<bits/stdc++.h>
using namespace std;
void f(string a){
	cout<<a[0];
}
int main(){
	string a;
	cin>>a;
	f(a);
	return 0;
}

一样也是最普通的传参

 

  • 12
    点赞
  • 27
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
C++中,结构体是一种用户自定义的数据类型,可以包含不同类型的成员变量和成员函数。结构体函数指的是将结构体作为递给函数。 结构体函数有以下几种方式: 1. 值递:将结构体作为递给函数时,会创建一个结构体的副本,并将副本递给函数。在函数内部对结构体的修改不会影响原始结构体的值。 2. 引用递:使用引用作为函数数,可以直接操作原始结构体的值,而不需要创建副本。在函数内部对结构体的修改会影响原始结构体的值。 3. 指针递:使用指针作为函数数,可以通过指针来访问和修改结构体的成员。在函数内部对结构体的修改会影响原始结构体的值。 下面是一个示例代码,演示了以上三种方式: ```cpp #include <iostream> using namespace std; struct Point { int x; int y; }; // 值递 void funcByValue(Point p) { p.x = 10; p.y = 20; } // 引用递 void funcByReference(Point& p) { p.x = 10; p.y = 20; } // 指针递 void funcByPointer(Point* p) { p->x = 10; p->y = 20; } int main() { Point p1 = {1, 2}; Point p2 = {3, 4}; Point p3 = {5, 6}; funcByValue(p1); cout << "p1 after funcByValue: (" << p1.x << ", " << p1.y << ")" << endl; funcByReference(p2); cout << "p2 after funcByReference: (" << p2.x << ", " << p2.y << ")" << endl; funcByPointer(&p3); cout << "p3 after funcByPointer: (" << p3.x << ", " << p3.y << ")" << endl; return 0; } ``` 输出结果为: ``` p1 after funcByValue: (1, 2) p2 after funcByReference: (10, 20) p3 after funcByPointer: (10, 20) ```

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值