分享知识 传递快乐
 
 
 
1、函数定义
 
linux shell 可以用户定义函数，然后在shell脚本中可以随便调用。Shell 函数定义的语法格式如下：
 
[function] funname [()]{
    函数体
    [return int;]
}
 
格式1：
 
简化写法，不写 function 关键字：
 
函数名(){
    函数体
}
 
格式2：
 
这是标准写法，也推荐大家使用的写法：
 
function 函数名(){
	命令序列
}
 
这样方便做到一看就懂。
 
格式3：
 
如果写了 function 关键字，也可以省略函数名后面的小括号：
 
function 函数名{
	命令序列
}
 

说明：
 
function 是 Shell 中的关键字，专门用来定义函数；可以带function funname () 定义，也可以直接funname () 定义，不带任何参数；
funname 是函数名；
函数体 是函数要执行的代码，也就是一组语句；
return int 表示函数的返回值，其中 return 是 Shell 关键字，专门用在函数中返回一个值；这一部分可以写也可以不写，如果不加，将以最后一条命令运行结果，作为返回值。
 
 
2、函数变量
 
Shell 函数的变量不像其它语言中需要在变量前定义变量类型什么的，更没有结果符号等。语法：
 
num=1
 
变量作用域
 
局部变量：作用域是函数的生命周期；在函数结束时被自动销毁。定义局部变量的方法：
 
local VAR=VALUE
 
本地变量：作用域是运行脚本的shell进程的生命周期；因此，其作用范围为当前shell
 
示例一：
 
#!/bin/bash

#在函数外定义本地变量
var="Hello,World"

function show() {
    #在函数内改变变量内容
    var="Hi,var is changed"
}
echo "$var"
show
echo "$var"
 
输出结果：
 
[guest@localhost shell]$ ./tempsh.sh
Hello,World
Hi,var is changed
 
结果显示在调用函数后，原有的本地变量var被替换了。还好这个变量并不是重要的部分，想想若是PATH被替换了，那么这个函数的罪过就大了。因此我们如何即调用函数中定义的变量同时又不对本地变量造成任何影响呢？局部变量的出现就是为了解决这个问题。
 
下面看看在使用了局部变量后的效果。
 
#!/bin/bash
#在函数外定义本地变量
var="Hello,World"

function show() {
    #在函数内改变变量内容
    local var="Hi,var is changed"
    echo "$var"
}
echo "$var"
show
echo "$var"
 
输出结果
 
[guest@localhost shell]$ ./tempsh.sh
Hello,World
Hi,var is changed
Hello,World
 
该实验结果说明，使用局部变量后，函数体中出现的变量作用范围只存在于当前函数生命周期。
 
 
 
3、函数调用
 
定义函数的代码段不会自动执行，而是在调用时执行；在函数定义好后，用户可以在shell 中直接调用，调用时不用带上()；调用 Shell 函数时可以给它传递参数，也可以不传递。如果不传递参数，直接给出函数名字即可。
 
示例一：
 
#!/bin/bash

# 函数定义
function show(){
    echo "Hello word"
}

# 函数调用
show
 
输出结果：
 
Hello word
 
函数调用成功。上边的例子是把函数把在脚本上边，那么如果放函数放在下边会怎样呢？
 
无非就两种结果：1成功，2失败
 
下面我们举例测试一下：
 
示例二：
 
#!/bin/bash

# 函数调用
show

#函数定义
function show(){
    echo "Hello word"
}
 
输出结果：
 
./tempsh.sh:行4: show: 未找到命令
 
系统报错，为啥？为什么会报错呢？
 
首先，脚本的执行顺序是从上到下顺序执行的，因此会先执行show，通过定义的环境变量$PATH定义的路径找不到show对应的命令因此报“show：未找到命令”。
 
我们在终端命令行中输错命令报错也是这个原因。终端命令行默认会将最左面输入的内容当做命令，因此若是错误的命令，不是命令的命令等内容都会报错。
 
通过上面的对比，我们至少知道函数的调用若是在同一个脚本中，调用操作需要在定义的函数后面。
 
 
 
4、函数传参
 
函数传参调用语法：
 
函数名 参数1 参数2 ....
 
如果传递参数，那么多个参数之间以空格分隔：
 
funname param1 param2 param3
 
不管是哪种形式，函数名字后面都不需要带括号。和其它编程语言不同的是，Shell 函数在定义时不能指明参数，但是在调用时却可以传递参数，并且给它传递什么参数它就接收什么参数。
 
在Shell中，调用函数时可以向其传递参数。在函数体内部，函数中的变量均为全局变量，没有局部变量，若使用局部变量需要在变量前加上 local，通过 $n 的形式来获取参数的值，例如，$1表示第一个参数，$2表示第二个参数....
 
示例：
 
#!/bin/bash

function show(){
    echo "第一个参数为 $1 !"
    echo "第二个参数为 $2 !"
    echo "第十个参数为 $10 !"
    echo "第十个参数为 ${10} !"
    echo "第十一个参数为 ${11} !"
    echo "参数总数有 $# 个!"
    echo "作为一个字符串输出所有参数 $* !"
}

show 0 1 2 3 4 5 6 7 8 9 10 11
 
输出结果：
 
第一个参数为 0 
第二个参数为 1 
第十个参数为 10 
第十个参数为 9 
第十一个参数为 10 
参数总数有 12 个
作为一个字符串输出所有参数 0 1 2 3 4 5 6 7 8 9 10 11 
 
注意：$10 不能获取第十个参数，获取第十个参数需要${10}。当n>=10时，需要使用${n}来获取参数。
 
另外，还有几个特殊字符用来处理参数：
 
参数处理
说明
$#
传递到脚本的参数个数
$*
以一个单字符串显示所有向脚本传递的参数
$$
脚本运行的当前进程ID号
$!
后台运行的最后一个进程的ID号
$@
与$*相同，但是使用时加引号，并在引号中返回每个参数。
$-
显示Shell使用的当前选项，与set命令功能相同。
$?
显示最后命令的退出状态。0表示没有错误，其他任何值表明有错误。
 
 
5、函数返回值
 
退出状态码
 
在介绍函数返回值前先了解一下跟函数返回值有关的状态退出码。
 
Shell 中运行的每个命令都使用退出状态码（exit status）来告诉shell它完成了处理。退出状态码是一个0-255之间的整数值，在命令结束运行时由命令传给shell。你可以捕获这个值并在脚本中使用。
 
如何查看退出状态码呢？
 
Linux提供了 $? 专属变量来保存上个执行的命令的退出状态码。你必须在你要查看的命令之后马上查看或使用 $? 变量。它的值会变成Shell中执行的最后一条命令的退出状态码。
 
退出状态码大体分两种：
 
一种是命令正确执行的状态码，该状态码为：0
一种是命令错误执行的状态码，为1-255
 Linux退出状态码
 
状态码
描述
0
命令成功结束
1
通用未知错误
2
误用shell命令
126
命令不可执行
127
没找到命令
128
无效退出参数
128+x
Linux信号x的严重错误
130
命令通过Ctrl+C终止
255
退出状态码越界
在脚本中也可以指定退出状态码的值，通过命令exit实现。
 
状态码取值范围为0-255，如果在指定的状态码大于255，那么shell会通过模（模就是256）运算得到相应的退出状态码。
 
示例一：
 
成功的
 
#!/bin/bash

# 函数定义
function show(){
    echo $(date +%Y%m%d)
}
show
echo $?
 
输出结果：
 
0
 
示例二：
 
失败的
 
#!/bin/bash

SYS_DATE=$(date +%Y%m%d)

echo $SYS_DATE

# 函数定义
function show(){
    log=`lt`
	echo log
}
show
echo $?
 
输出结果：
 
[guest@localhost shell]$ ./tempsh.sh 
20191123
./tempsh.sh:行10: lt: 未找到命令
log
0
 
这次，由于函数最后一行命令正确执行，函数的退出状态码就是0，尽管函数中有一条命令没有成功运行。
 
使用函数的默认退出状态码是很危险的，幸运的是return命令可以解决这个问题。
 
示例：
 
#!/bin/bash

SYS_DATE=$(date +%Y%m%d)

echo $SYS_DATE

# 函数定义
function show(){
    log=`lt`
	echo log
	return 2
}
show
echo $?
 
输出结果：
 
[guest@localhost shell]$ ./tempsh.sh 
20191123
./tempsh.sh:行10: lt: 未找到命令

2
 
还是使用相同的函数，在函数最后加上return指定的状态码2。
 
 
 
函数返回值
 
Shell函数返回值，常用的两种方式：return、echo。
 
 
 
1）return 语句
 
Shell函数的返回值，可以和其他语言的返回值一样，通过return语句返回，return只能用来返回整数值。
 
示例一：
 
#!/bin/bash

function getResultFun(){
    echo "这是我的第一个 shell 函数!"
    return `expr 1 + 1`
}

getResultFun
echo $?
 
输出结果：
 
这是我的第一个 shell 函数!
2
 
Shell 函数返回值只能是整形数值，一般是用来表示函数执行成功与否的，0表示成功，其他值表示失败。用函数返回值来返回函数执行结果是不合适的。如果return某个计算结果，比如一个字符串，往往会得到错误提示：“numeric argument required”。
 
如果一定要让函数返回一个或多个值，可以定义全局变量，函数将计算结果赋给全局变量，然后脚本中其他地方通过访问全局变量，就可以获得那个函数“返回”的一个或多个执行结果了。
 
示例：
 
#!/bin/sh

function getStr(){
	return "string"
}

getStr
echo $?
 
输出如下：
 
./test.sh: line 5: return: string: numeric argument required
255
 
可以看到已经提示要求return 整数类型，真实返回值是255。当面对这种问题怎么解决呢？
 
别急，断续看下去你就会找到你想要的答案了。
 
 
 
2）echo 语句
 
echo是通过输出到标准输出返回，可以返回任何类型的数据。
 
示例：
 
#!/bin/sh

function test()  {
	echo "arg1 = $1"
	if [ $1 = "1" ] ;then
		echo "1"
	else
		echo "0"
	fi
}

echo
echo "test 1"
test 1

echo
echo "test 0"
test 0

echo
echo "test 2"
test 2
 
输出结果：
 
test 1
arg1 = 1
1

test 0
arg1 = 0
0

test 2
arg1 = 2
0
 
 
 
3）函数返回值总结
 
学习了上面的函数返回值的操作后我们下面做个知识总结，我们先看一用例：
 
#!/bin/bash

function getResultFun(){
    echo "这是我的第一个 shell 函数!"
    return `expr 1 + 1`
}

getResultFun
echo $?

function getResultFun2(){
 echo "这是我的第二个 shell 函数!"
 expr 1 + 1
}

getResultFun2
echo $?

getResultFun
echo 在这里插入命令！
echo $?
 
输出结果：
 
这是我的第一个 shell 函数!
2
这是我的第二个 shell 函数!
2
0
这是我的第一个 shell 函数!
在这里插入命令！
0
 
这是为什么？
 
因为调用 getResultFun2 后，函数最后一条命令 expr 1 + 1 得到的返回值（$?值）为 0，意思是这个命令没有出错。所有的命令的返回值仅表示其是否出错，而不会有其他有含义的结果。
 
第二次调用 getResultFun 后，没有立即查看 $? 的值，而是先插入了一条别的 echo 命令，最后再查看 $? 的值得到的是 0，也就是上一条 echo 命令的结果，而 getResultFun 的返回值被覆盖了。下面这个测试，连续使用两次 echo $?，得到的结果不同，更为直观：
 
#!/bin/bash

function getResult(){
    echo "这是我的第一个 shell 函数!"
    return `expr 1 + 1`
}

getResult
echo $?
echo $?
 
输出结果：
 
这是我的第一个 shell 函数!
2
0
 
 
 
6、获取函数返回值
 
我们上面谈到了函数定义、传参、调用、返回结果，那我们如果得到返回结果呢？上面也谈到了一种获取返回结果的方法 $? ，难道只有这一种方式吗？答案肯定不止。
 
示例一：
 
用 $? 获取返回值，上面已有介绍，在这里就不做介绍了。
 
示例二：
 
#!/bin/sh

function getStr(){
	return "string"
}

#方法一
echo `getStr` 

#方法二
echo $(getStr) 
 
两种写法的原理一样的，将getStr当成命令执行，然后获取其标准输出。
 
示例三：函数传参
 
#!/bin/bash

#创建目录
function createDir(){
	if [ ! -d $1 ]; then
		mkdir -p $1
	fi
}

DIR="temp/"
# 两者二先一
#$(createDir $DIR)
$(createDir "temp/")
 
函数返回值获取的方法总结：
 
用变量接收函数返回值，函数用echo等标准输出将要返回的东西打印出来。
用 $? 来接收函数的执行状态，但是 $? 要紧跟在函数调用处的后面。
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
———————————
 相互学习，共同进步
 如有不足请留言指正

首先，强调一点，和函数传参一样，函数返回时也会做一个拷贝。从某种角度上看，和传参一样，也分为三种：
 
返回值：返回任意类型的数据类型，会将返回数据做一个拷贝（副本）赋值给变量；由于需要拷贝，所以对于复杂对象这种方式效率比较低（调用对象的拷贝构造函数、析构函数）；例如：int test(){}或者 Point test(){}
返回指针：返回一个指针，也叫指针类型的函数，在返回时只拷贝地址，对于对象不会调用拷贝构造函数和析构函数；例如：int *test(){} 或者 Point *test(){}
返回引用：返回一个引用，也叫引用类型的函数，在返回时只拷贝地址，对于对象不会调用拷贝构造函数和析构函数；例如：int &test(){}或者 Point &test(){}
一般来说，在函数内对于存在栈上的局部变量的作用域只在函数内部，在函数返回后，局部变量的内存会自动释放。因此，如果函数返回的是局部变量的值，不涉及地址，程序不会出错；但是如果返回的是局部变量的地址（指针）的话，就会造成野指针，程序运行会出错。因为函数只是把指针复制后返回了，但是指针指向的内容已经被释放，这样指针指向的内容就是不可预料，调用就会出错。
 
1、返回值：
 
int test1() {
  int a = 1;
  return a;
}
 
返回值是最简单有效的方式，他的操作主要在栈上，根据函数栈的特性局部变量a会在函数结束时被删除，为了返回a的值，需要产生a的复制。如果a原子类型这当然也无所谓，但是如果a是大的对像，那么对a的复制将会产生比较严重的资源和性能消耗。
 
注：函数返回值本身因为没有名称或引用，所以是右值，是不能直接操作的。
 
2、指针类型的函数——返回指针：
 
若函数的返回值是指针，该函数就是指针类型的函数。（即函数return一个指针，该指针可以是任何类型的）
 
1）指针类型的函数定义：
 
<类型> *函数名(参数)
 
int *test1() {
  int *b = new int();
  *b = 3;
  return b;
}
 
根据函数栈的特性也会产生复制，但是这个复制只是4（或8）字节，对于返回大型对像或数组来说可减少资源。但是返回指针资源的清理工作交给了调用者，这某种意义上违反了谁申请谁销毁的原则。
 
注：函数返回指针也是右值，同样无法操作。
 
2）说明：
 
不要将非静态局部地址用作函数返回值：因为局部地址在离开函数后就失效了。
可以在函数中用动态内存分配（new）的地址返回，但需要注意内存分配和释放不在同一级别，不要忘记释放，否则内存泄露；
可以在主调函数中定义数组，函数中对该数组进行操作，然后返回其中一个元素的地址；
 
3、返回引用：
 
1）引用类型函数的定义：
 
<类型> &函数名(参数)
 
int &test3() {
  int *c = new int();
  *c = 5;
  return *c;
}
 
引用是C++中新添加的概念，所以返回引用也是C++中相对于C来说所没有的。引用是值的别名，和指针一样不存在对大对像本身的复制，只是引用别名的复制。引用是左值，返回引用可以直接操作，也就可以进行连续赋值，最经典的示例是拷贝构造函数和运算符重载一般返回引用。
 
test3() +=3;
 
 
2）说明：
 
和返回指针一样，不要将非静态局部变量的引用用作函数返回值：因为局部地址在离开函数后就失效了。
和返回指针一样，用动态内存分配（new）的局部指针可以作为引用返回，但是和返回指针一样需要调用者自己去清理内存，否则内存泄露；
总结：
 
在C时代函数只能返回值、指针两种，这两种返回的都是右值；前者对于返回对象时要进行拷贝，效率比较低（会执行对象的拷贝构造函数、析构函数），后者不会发生；
C++时代除了上面两种外，多了返回引用，这种返回时一种左值，特性和返回指针一样；
 
3、综合示例：
 
1）返回栈内局部变量：
 
#include <iostream>
using namespace std;
int fun1() {
    int i = 1;
    cout<<"fun1 i address"<<&i<<endl;
    return i;//ok,返回值是i值得拷贝
}
int *fun2() {//指针类型的函数
    int i = 2;
    int *ip = &i;
    cout<<"fun2 i address"<<ip<<endl;
    return ip; // Wrong!返回值是ip指针的拷贝,但该地址在函数结束后会释放变得无效
}
int main() {
    int r1 = fun1();
    cout<<"main fun1 return i address"<<&r1<<endl;
    cout << r1 << endl; // 1
 
    int *r2 = fun2();
    cout<<"main fun2 return i address"<<r2<<endl;
    //这里有可能出错:具体看对应的内存是否被覆盖,但总之该内存已无效
    cout << *r2 << endl;//0

    return 0;
}
 
输出：
 
fun1 i address0x7ffc49e9b69c
main fun1 return i address0x7ffc49e9b6b4
1
fun2 i address0x7ffc49e9b694
main fun2 return i address0x7ffc49e9b694
0
 
我们在看一个对象的例子：
 
#include <iostream>

using namespace std;

class Point {
  public:
    Point(int a,int b):x(a),y(b){}
    int getX();
    void setX(int x);
  private:
    int x,y;
};

int Point::getX(){
  return x;
}
void Point::setX(int a) {
  x = a;
}
Point func(int x) {
  Point p(x,100);
  cout<<"func1 p address:"<<&p<<endl;
  return p;//ok,发生一次Point拷贝
}
Point *func2(int x) {//指针函数
  Point p(x,200);
  cout<<"func2 p address:"<<&p<<endl;
  return &p;//wrong,返回值是p地址的拷贝,但该地址在函数结束后会被释放变得无效
}
main() {
  Point p = func(1);
  cout<<"main return p address:"<<&p<<endl;
  cout<<"main return p x:"<<p.getX()<<endl;

  Point *p2 = func2(2);
  cout<<"main return p address:"<<p2<<endl;
  cout<<"main return p x:"<<p2->getX()<<endl;
}
 
编译的时候会有一个警告：
 
test88.cpp: In function ‘Point* func2(int)’:
test88.cpp:26:9: warning: address of local variable ‘p’ returned [-Wreturn-local-addr]
   Point p(x,200);
         ^
 
输出：
 
func1 p address:0x7fff0f005270
main return p address:0x7fff0f005290
main return p x:1
func2 p address:0x7fff0f005270
main return p address:0x7fff0f005270
main return p x:6299776
 
结论：对于栈内局部变量，采用一般的返回值，实际上是对返回值的一次值拷贝，在内存里会有两个示例；对于指针类型函数的返回值，实际上是对地址的一次拷贝，内存只有一个示例，但该地址是一个非法的地址，在使用时会出现问题。
 
2）返回字符串：
 
通过 char* s = “Hello”; 的方式得到的是一个字符串常量 Hello，存放在只读数据段（.rodata section），把该字符串常量的只读数据段的首地址赋值给了指针 s，所以函数返回时，该字符串常量所在的内存不会被回收，所以能正确地通过指针访问。
 
#include <iostream>
using namespace std;

char *fun1() {
  char *s="hello";
  return s;//ok
}

int main() {
  char *c1 = fun1();
  cout<<c1<<endl;
  //常量，无法在修改 
  
  return 0;
}
 
3）静态变量：
 
可以把局部变量声明为static静态变量。这样变量存储在静态存储区，程序运行过程中一直存在。
 
int *fun3(){
  static int i = 5;
  cout<<"fun3 i address:"<<&i<<endl;
  return &i;
}
int main() {

  int *r1 = fun3();
  cout<<"main return i address:"<<r1<<endl;
  cout<<*r1<<endl;
}
 
输出：
 
fun3 i address:0x602078
main return i address:0x602078
5
 
4）数组：
 
数组是不能作为函数的返回值的。因为编译器会把数组名认为是局部变量（数组）的地址。返回一个数组，实际上是返回指向这个数组首地址的指针。函数结束后，数组作为局部变量被释放，这个指针则变成了野指针。但是声明数组是静态的，然后返回是可以的。
 
int *fun4() {
  static int a[2]={4,5};
  cout<<"fun4 a[] address:"<<&a<<endl;
  return a;
}
int main() {
  int *r2 = fun4();
  cout<<"main return a[] address:"<<r2<<endl;
  cout<<*r2<<endl;
}
 
输出：
 
fun4 a[] address:0x60207c
main return a[] address:0x60207c
4
 
5）堆内变量：
 
函数返回指向存储在堆上的变量的指针是可以的。但是，程序员要自己负责在函数外释放（free/delete）分配。
 
int *fun5() {
  int *j = new int;
  *j = 99;
  cout<<"fun5 j address:"<<j<<endl;
  return j;
}
int main() {

  int *r3 = fun5();
  cout<<"main return j address:"<<r3<<endl;
  cout<<*r3<<endl;
  *r3 = 100;
  cout<<*r3<<endl;
  delete r3;
}
 
输出：
 
fun5 j address:0x208b010
main return j address:0x208b010
99
100
 
综上，C++的函数返回和函数传参有所不同，返回值和传参一样也有三种类型：
 
使用一般（传统）的函数返回，对于复杂对象会涉及到拷贝效率问题；
使用指针类型的函数会有很多限制和弊端（容易内存泄露）；
引用类型的函数又是一个鸡肋；
所以一般C++函数都是用传址的方式进行双向数据绑定，而返回值仅仅是一个成功或失败的标志。
 
参考：
 
https://blog.csdn.net/cnsword/article/details/7256821
 
https://zh4ui.net/post/2018-08-07-cplusplus-return-value-or-reference/

函数的返回值是指函数被调用之后，执行函数体中的代码所得到的结果，这个结果通过 return 语句返回。
 
return 语句的一般形式为：
 
return 表达式;
 
或者：
 
return (表达式);
 
有没有( )都是正确的，为了简明，一般也不写( )。例如：
 
return max;
return a+b;
return (100+200);
 
C语言返回值
 
1 . 没有返回值的函数为空类型，用void表示。例如：
 
void func(){
    printf("http://www.baidu.com\n");
}
 
一旦函数的返回值类型被定义为 void，就不能再接收它的值了。例如，下面的语句是错误的：
 
int a = func();
 
为了使程序有良好的可读性并减少出错， 凡不要求返回值的函数都应定义为 void 类型。
 
2 . return 语句可以有多个，可以出现在函数体的任意位置，但是每次调用函数只能有一个 return 语句被执行，所以只有一个返回值。
 
示例
 
//返回两个整数中较大的一个
int max(int a, int b){
    if(a > b){
        return a;
    }else{
        return b;
    }
}
 
如果a>b成立，就执行return a，return b不会执行；如果不成立，就执行return b，return a不会执行。
 
3 . 函数一旦遇到 return 语句就立即返回，后面的所有语句都不会被执行到了。return 语句还有强制结束函数执行的作用。
 
示例
 
//返回两个整数中较大的一个
int max(int a, int b){
    return (a>b) ? a : b;
    printf("Function is performed\n");
}
 
第 4 行代码则永远不会被执行。
 
我们定义了一个判断素数的函数，这个例子更加实用：
 
#include <stdio.h>

int prime(int n){
    int is_prime = 1, i;

    //n一旦小于0就不符合条件，就没必要执行后面的代码了，所以提前结束函数
    if(n < 0){ return -1; }

    for(i=2; i<n; i++){
        if(n % i == 0){
            is_prime = 0;
            break;
        }
    }

    return is_prime;
}

int main(){
    int num, is_prime;
    scanf("%d", &num);

    is_prime = prime(num);
    if(is_prime < 0){
        printf("%d is a illegal number.\n", num);
    }else if(is_prime > 0){
        printf("%d is a prime number.\n", num);
    }else{
        printf("%d is not a prime number.\n", num);
    }

    return 0;
}
 
prime() 是一个用来求素数的函数。素数是自然数，它的值大于等于零，一旦传递给 prime() 的值小于零就没有意义了，就无法判断是否是素数了，所以一旦检测到参数 n 的值小于 0，就使用 return 语句提前结束函数。
 
return 语句是提前结束函数的唯一办法。return 后面可以跟一份数据，表示将这份数据返回到函数外面；return 后面也可以不跟任何数据，表示什么也不返回，仅仅用来结束函数。
 
我们让 return 后面不跟任何数据：
 
#include <stdio.h>

void prime(int n){
    int is_prime = 1, i;

    if(n < 0){
        printf("%d is a illegal number.\n", n);
        return;  //return后面不带任何数据
    }

    for(i=2; i<n; i++){
        if(n % i == 0){
            is_prime = 0;
            break;
        }
    }

    if(is_prime > 0){
        printf("%d is a prime number.\n", n);
    }else{
        printf("%d is not a prime number.\n", n);
    }
}

int main(){
    int num;
    scanf("%d", &num);
    prime(num);

    return 0;
}
 
prime() 的返回值是 void，return 后面不能带任何数据，直接写分号即可。
 
扫一扫获取更多资讯哟！！！
 

int  f2(double p ,double& nn,int& n,int& bb)
{
	int test = 3;
	for (int i = 0; i < 5; ++i) {
		std::cout << "Thread 2 executing\n";
		
		//std::this_thread::sleep_for(std::chrono::milliseconds(10));
	}
	bb = test;
	return  bb;
}
std::thread *t2;
int main()
{
	double st;
	int n = 0;
	int n1 = 0;
	double n11 = 0;
	int result = 0;
	//t2 =new thread(f2, ref(n), ref(n1)); // pass by value
	//(*t2).detach();

	t2 = new thread([&] {result = f2(0.0, n11,n, n1); }); // set numberOne = 1;
	(*t2).detach();
	std::this_thread::sleep_for(std::chrono::milliseconds(10));
	TRACE("#########################%d \n", result);
}