如何用main函数输出（怎么使用带参数的main函数）？如果你对这个不了解，来看看！
交换变量值的两种方式，下面是腾峰说故事给大家的分享，一起来看看。
如何用main函数输出
交换变量值的两种方式
两个整型指针变量，通过指针方式交换两个整型变量的所赋的值，第一种方法通过交换两个整型变量的地址指针实现，而存放这两个整型变量首地址的指针变量随着这两个整型变量地址的交换而存放的两个首地址也会交换。第二种通过用指针变量所指变量值（指针）来互相赋值，直接达到交换两个指针变量所指的变量的值的目的。
1.交换两个变量的地址（指针变量），其对应的变量值不会改变。只是变量地址被交换了，读取变量的值会变，交换了变量所指的值。交换地址变量是指针地址，原指向变量值不变，只是指针所指向的内容变了。
例：输入a 和 b 两个整数，按先大后小的顺序输出 a 和 b 。
用指针变量方法来处理这个问题。不交换整型变量的值，而是交换两个指针变量的值（地址值）。
编写程序：
# include < stdio . h >
int main ()
int * p1，*p2,* p，a，b ;// pl ,p2的类型是 int *类型
printf（" please enter two integer numbers :"); scanf（"% d ,%d"，&a，& b );//输入两个整数
p1=&a;
p2=& b ;
//使p1指向变量 a
//使 p2指向变量 b
if ( a < b )
( p = p1 ; p1=p2;p2= p ;)//如果 a < b ，使 p 1与 p2的值（地址）互换
printf（" a =% d,b =% d \n"， a , b ）;
printf (" max =% d , min =% d \,* p1,*p2);
return 0;
//输出 a , b
//输出 p1和p2所指向的变量的值
运行结果：
please enter two integer nunbers :5,9
a=5,Ь=9
max=9,min=5
输入 a =5, b =9后，由于a<b ，需将 p1和p2交换。
并未交换a,b的值，只是交换了p1,p2的值（地址值），交换了p1,p2所指向的地址，相当交换了a,b的地址，不是交换＊p1及＊p2的值。
中间指针变量＊p，是指针类型 。
p=p1;//并未交换a,b的值，只是交换了p1,p2的值，交换了p1,p2所指向的地址，相当交换了a,b的地址）
p1=p2;
p2=p;
注意： a 和 b 的值并未交换，它们仍保持原值，但 p1 和p2的值改变了。 p1的值原为& a ，后来变成& b，p2原值为& b ，后来变成& a 。这样在输出＊ pl 和*p2时，实际上是输出变量 b 和 a 的值，所以先输出9，然后输出5。
两个变量的值交换要利用第3个变量。实际上，可以改为
{ p1=& b ;p2=& a ;｝直接对 p1 和p2赋以新值，这样可以不必定义中间变量 P ，便程序更加简练。如果超过2个，仍用中间变量容易混淆，一般通过建立第三个变量来交换数值；不建立变量，通过运算的方式交换，如果两数值过大，则可能会溢出，养成好习惯。
这个问题的算法是不交换整型变量的值，而是交换两个指针变量的值（即 a 和 b 的地址）。
2指针变量作为函数参数
函数的参数不仅可以是整型、浮点型、字符型等数据，还可以是指针类型。它的作用是将一个变量的地址传送到另一个函数中。
例：对输入的两个整数按大小顺序输出。如果用函数处理，而且用指针类型的数据作函数参数。
第一种方式中直接在主函数内交换指针变量的值（地址交换，不改变量值），现在在主函数之外定义一个交换函数 swap 将指向两个整型变量的指针变量（内放两个变量的地址）作为实参传递给 swap 函数的形参指针变量，在函数中通过指针实现交换两个变量的值。
“指针”和“指针变量”的区别
区别在于：1、一个变量的(内存)地址称为该变量的“指针”，＊p是说指针变量为p，通过指针能找到以它为地址的内存单元。而指针变量是用来存放另一个变量的地址的（即指针），存放地址的变量称为指针变量。指针变量是一种特殊的变量，它不同于一般的变量，一般变量存放的是数据本身，而指针变量存放的是数据的地址。2.如果一个指针变量存放的是某个对象的地址，则称这个指针变量指向该对象。
系统为每一个内存单元分配一个地址值，把这个地址值称为“指针”。如有int i=5;，存放变量i的内存单元的编号(地址)&i被称为指针。“指针变量”则是存放“地址值”的变量，“指针变量”是存放变量所占内存空间“首地址”的变量(因为一个变量通常要占用连续的多个字节空间)。比如在int i=5；后有一句int *p=&i；，就把i的地址&i赋给了int 型指针变量p，也就是说p中存入&i。int *p就是说指针变量是存放指针的变量。
指针变量，就是一个存放地址的变量，通常定义整形，实型等变量后，系统给变量分配一定的内存单，用来存放数据的，而定义一个指针变量给它分配的空间是用来存放地址的。且只能存放地址
编写程序：
# include < stdio . h >
int main ()
｛ void swap（int * p1, int *p2);//对 swap 函数的声明
int a , b ;
int * pointer _1,* pointer _2; //仅限定义两个 int 型的指针变量，定义声明不等于说指向某整形变量，未被赋值，指针变量名赋值取变量地址。
printf (" please enter a and b :"）;
scanf ("% d ,% d ",& a ,&Ь); //输入两个整数
pointer _1=& a ;
pointer _2=&b ;
//使 pointer _1指向 a
//使 pointer _2指向 b
if ( a < b ) swap ( pointer _1, pointer _2);
printf (" max =% d , min =% d \n", a , b );
//如果 a<b ，调用 swap 函数
//输出结果
return 0;｝
自定义交换函数
void swap ( int * p1, int *p2)
{ int temp；
temp =* p1；* p1=＊p2;
＊p2= temp ;
//定义 swap 函数
//使＊ p1和＊p2互换
运行结果：
please enter a and b :5,9 max=9,min=5
swap 是用户自定义函数，它的作用是交换两个变量（ a 和 b ）的值。 swap 函数的两个形参p1和p2是指针变量。有人说交换函数形参是带＊p1，＊p2，而调用交换函数swap ( pointer _1, pointer _2); 两个类型有不同，带＊p仅表示p属于指针变量，运用指针必须在定义后用指针址址变量p，所以两者是一类，都是指针变量。
程序运行时，先执行 main 函数，输入 a 和 b 的值（在这里输入5和9)。然后将 a 和 b 的地址分别赋给 int *变量 pointer _1和 pointer _2，使 pointer _ 1 指向 a , pointer _2指向b，接着执行 if 语句，由于 a<b，因此执行 swap 函数。注意带＊指针指向对象必须在定义后被赋值初始化后方可被允许使用。
另外实参 pointer _1和 pointer _2是指针变量，在函数调用时，将实参变量的值传送给形参变量，采取的依然是值传递方式。传变量地址就是传变量的值。形参 p1 的值为& a，p2的值为& b ，这时p1和 pointer _1都指向变量 a ,p2和 pointer _2都指向 b 。接着执行 swap 函数的函数体，使“ *p1和＊p2的具体指向地址值互换，也就是使 a 和 b 的值互换。
函数调用结束后，形参 p1和p2不复存在（已释放），最后在 main 函数中输出的 a 和 b 的值已是经过交换的值（ a =9, b =5)。
请注意交换＊p1和＊p2的值是如何实现的。如果写成以下这样就有问题了：
void swap ( int * p1， int *p2)
{ int * temp ;
*temp = *p1;* p1=*p2;
*p2= *temp；
//此语句有问题
*p1就是 a ，是整型变量。而＊temp 是指针变量 temp 所指向的变量。带＊指针指向对象必须在定义后被直接赋值初始化后方可被允许使用或运算。
但由于未给temp 赋值初始化，这样直接有可能破坏系统的正常工作状况，应该将＊ p1 的值赋给与 p1 相同类型的变量，而用整型变量 temp 作为临时辅助变量实现*p1和＊p2的交换。
采取的方法是交换 a 和 b 的值，而 p1和p2的指向地址值不变。可以看到，在执行 swap 函数后，变量 a 和 b 的值改变了。
设置其它自定义函数功能测试实现 a 和 b 互换的目的。
void swap ( int x , int y )
{ int temp :
temp=x ; x=y；
y = temp
如果在 main 函数中调用 swap 函数：swap ( a , b );
在函数调用时， a 的值传送给 x , b 的值传送给 y ，执行完 swap 函数后， x 和 y 的值是互换了，但并未影响到 a 和 b 的值。在函数结束时，变量 x 和 y 释放了， main 函数中的 a 和 b 并未互换，也就是说，由于“单向传送”的“值传递”方式，形参值的改变不能使实参的值随之改变。
为了使在函数中改变了的变量值能被主调函数 main 所用，不能采取上述把要改变值的变量作为参数的办法，而应该用指针变量作为函数参数，在函数执行过程中使指针变量所指向的变量值发生变化；函数调用结束后，这些变量值的变化依然保留下来，这样就实现了“通过调用函数使变量的值发生变化，在主调函数（如 main 函数）中可以使用这些改变了的值”的目的。
如果想通过函数调用得到 n 个要改变的值，可以这样做：
1在主调函数中设 n 个变量，用 n 个指针变量指向它们；
2设计一个函数，有 n 个指针形参。在这个函数中改变这 n 个形参的值；在主调函数中调用这个函数，在调用时将这 n 个指针变量作实参，将它们的值，也就是相关变量的地址传给该函数的形参；
3在执行该函数的过程中，通过形参指针变量，改变它们所指向的 n 个变量的值；（第二种方式）
4主调函数中就可以使用这些改变了值的变量。
注意：不能企图通过改变指針形参的值而使指针实参的值改变，推荐第二方式。
指针变量
怎么使用带参数的main函数
#头条创作挑战赛#
本文同步本人掘金平台的文章：https://juejin.cn/post/7126370463584321573
Dart 是一种真正面向对象的语言，所以即便函数也是对象并且类型为 Function，这意味着函数可以被赋值给变量或者作为其它函数的参数。
推荐使用线上编辑器 dartpad.cn 进行学习，测试～
参数函数有两种形式的参数：
必要参数：放在参数列表的前面可选参数：放在参数列表的后面，其又可以分为两种 命名参数：使用花括号 {} 括起来的参数 位置参数：使用方括号 [] 括起来的参数// 命名参数void main() { // sayHi(); // 报错，因为第一个参数是必要参数 sayHi(' Jimmy '); // Hello Jimmy nullnull sayHi(' Jimmy ', name2: 'and Timmy.'); // Hello Jimmy and Timmy.null}void sayHi(String name1, { String? name2, String? name3 }) { print('Hello' + name1 + name2.toString() + name3.toString());}复制代码注意：如果一个参数是可选的，但是不能为 null，你需要为它提供一个默认值。
我们更改一下上面的代码：
void main() { sayHi(' Jimmy '); // Hello Jimmy ,Timmy and Kimmy.}void sayHi(String name1, { String name2 = ',Timmy ', String name3 = 'and Kimmy.' }) { print('Hello' + name1 + name2 + name3);}复制代码上面的命名参数是使用 key: value 的形式调用的，而下面要讲的位置参数，是在指定的位置，填写 value 值即可，改写上面的代码如下：
void main() { sayHi(' Jimmy ', ' and Kimmy.', ''); // Hello Jimmy and Kimmy.}void sayHi(String name1, [String name2 = ',Timmy ', String name3 = 'and Kimmy.']) { print('Hello' + name1 + name2 + name3);}复制代码ps：命名参数和位置参数，其调用的方式不同
main 函数每个 Dart程序都必须有一个，main 函数程序的入口。Flutter 应用程序也是从 main 函数启动的。
void main() => runApp(MyApp());// MyApp 是一个类复制代码函数可以作为参数传递函数是一级对象，可以将函数作为参数传递给另一个函数。比如：
void sayHi(String name) { print(name);}var list = ['Jimmy', 'Timmy', 'Kimmy'];list.forEach(sayHi);// Jimmy// Timmy// Kimmy复制代码匿名函数匿名函数顾名思义，即使没有函数名称。我们可以创建一个没有名字的方法，称之为匿名函数、 Lambda 表达式 或 Closure 闭包。
完整的语法格式如下：
([[类型] 参数[, ...]]) { 函数体}复制代码比如：
var list = ['Jimmy', 'Timmy', 'Kimmy'];list.forEach((String item) { print(item);});// Jimmy// Timmy// Kimmy复制代码词法作用域Dart 是词法作用域语言，意味着变量的作用域是静态确定的。变量的作用域在写代码的时候就确定了，大括号内定义的变量只能在大括号内访问。比如：
String outMain = 'out main';void main() { String insideMain = 'inside main'; sayHi(); print(outMain); // out main print(name); // 报错}void sayHi() { String name = 'Jimmy'; print(outMain); // out main// print(insideMain); // 报错 print(name); // Jimmy}复制代码词法闭包闭包就是一个函数对象，即使函数对象的调用在它原始作用域之外，依然能够访问它词法作用域内的变量。比如：
// 闭包就是一个函数对象Function sayHi(String prefix) { return (String name) => prefix + name;}void main() { var sayHi1 = sayHi('Hello '); var sayHi2 = sayHi('Hi '); print(sayHi1); // Closure 'sayHi_closure' print(sayHi2); // Closure 'sayHi_closure' print(sayHi1('Jimmy.')); // Hello Jimmy. print(sayHi2('Jimmy.')); // Hi Jimmy.}复制代码关于闭包，后面会专门出一篇文章讲解，敬请期待...
往期精彩推荐Dart 知识点 - 数据类型Dart 知识点 - 运算符Dart 知识点 - 流程控制语句