本文为原创,是本人自学c++时所写的笔记,如果有什么错误的地方请在本文下留言,我会第一时间改正。

include<iostream>

include<cmath>

using namespace std;

//自定义函数,无返回值,无参
void hanshu() {

cout << "我是自定义函数" << endl;

/*
在定义自定义函数时需要提供所必要的数据,一是如果有返回值则要声明返回值的类型,如果没有返回值则使用void。
二是提供函数名。三是提供()如果函数需要接收参数则在里面声明接收参数的类型和个数,如果不需要参数则为空,()不能省略。
四是最后的{},里面是函数的主体。
上述例子是一个无返回值,无参的自定义函数。

*/

}

//有返回值无参的自定义函数
//函数的返回值可以赋给新的变量或者用于其他表达式中
//c++有返回值的函数返回值不能是数组,但是可以将数组作为结构和对象的一部分进行返回。
int huanshu_2() {

return 5;

/*
在定义有返回值的自定义函数时,需要提供会返回值类型的数据类型,并且使用return返回返回值。
*/
}

//有参无返回值的自定义函数
void hanshu_3(string d) {

cout << d << endl;

/*
有参的自定义函数需要声明参数的数据类型和个数。
*/
}

//有参(多参)有返回值的自定义函数
int hanshu_4(int a, int b) {

int c = a + b;
return c;

/*
有返回值有参的自定义函数,需要同时提供返回值的类型与参数的数据类和个数。
*/
}

//自定义函数与数组
//函数的参数类型也可以是数组形式
void hanshu_5(int arr[], int a) {

int num = arr[2] + a;
cout << num << endl;

/*
自定义函数的参数也可以数数组,在定义时需要提供数组的类型,名称以及[],方括号为空表示可以传递任意长度的数组进来。
在形参中的arr实际上不是一个真正的数组,它实际上是一个指针。

------------------------------------------------------------------------------------------------

将数组作为参数意味着(arr实际上是一个指针,而不是一个真正意义上的数组)程序实际并没有把数组的内容传递给函数,
而是将数组的地址,包含的元素种类以及元素数目提交给了函数。但是在传递常规变量时函数使用的方法是拷贝,也就是说
在传递常规变量时函数使用的是变量的副本,不是变量本身。但是在传递数组时函数使用的时原来的数组。

-------------------------------------------------------------------------------------------------

const关键字可以让被修饰的属性变为只读的状态。例如 void henshu_5(const int arr[],int a)(){}
这时函数的数组数组就只能读取而不能做出任何的修改,这样做是为了保护原数据的安全,原因是在第52-54行。
*/
}

//函数与二维数组
void hanshu_6(int arr[][3], int a) {

int b = arr[1][2] + a;
cout << "函数与二维数组输出" << endl;
cout << b << endl;

/*
在自定义的函数参数列表中使用二位数组,需要提供数组类型,以及数组的列的长度(列的长度是必须提供的),可以不提供行的长度
但是要提供列的长度。二位数组的数组名被视为是数组的地址,相应的形参是一个指针,形如arr3其实是4个指向int的指针数组。
*/
}

//数组与字符串(char)
void hanshu_7(char *arr) {//参数形式也可以是(char arr[]),两种声明形式均可

cout << "数组与字符串输出" << endl;
cout << arr << endl;

/*
将字符串作为参数时,意味着传递的是地址,实际上传递的是字符串第一个字符的地址。在形参中的arr实际上是一个指针,
它指向的是字符串第一个字符的地址,如果对arr进行加减,将会让指针的位置便宜,加则移到后一个字符的位置,减则相反。
*/
}

//返回字符串数据
char * hanshu_8(char arr, int n) {

char* num = new char(n + 1);
num[n] = '\0';
while (n-- > 0) {
    num[n] = arr;
}
return num;

/*
实际上函数不能返回字符串类型的数据,上述例子里函数返回的是一个指针(第74行已经声明),返回的是字符串的地址。
上述例子中显示声明了一个char类型的指针num,然后为它在堆区开辟了一块大小为arr字符串长度+1的空间,并且把结尾设置为空值字符。
然后进行填充(形参中的n是字符串的长度),当n的值小于0时结束while循环,填充完毕。在整个函数执行完毕后,因为num(不是字符串)的作用域
为hanshu_8函数内部,所以在函数结束后会被系统释放,但是由于函数返回了num的值,所以程序仍然可以通过main()函数中的指针(在main函数中声明一个指向hanshu_8的指针ps)
ps来访问新建的字符串。

在函数结束时原来函数中的数据已经被释放,但是因为数据被返回,所以在内存中这时已经开辟出另一块新的区域来存放返回值
,所以可以通过main函数中事先声明的指向其自定义的指针来获取返回值。
*/
}
//函数和结构
/*
结构:结构是用户定义的数据类型,就像是数组一样可以存储多个数据,但是比数据更加灵活。可以在一个结构
中存储不同的数据类型。
函数与结构:结构将其数据组合成一个数据实体或者是数据对象,该实体被视为一个整体。这样可以将结构进行传递,
可以将结构以参数的形式传递给函数,同样函数的返回值也可以是结构。但是结构和数组不同,在传递数组时,传递的
是数组的首地址,在传递结构时想传递结构的地址则要使用&(取地址符)才可以。当结构较小时,可以使用按值传递的
方式来传递结构(按值传递形式传递结构,是把整个结构体传递回去,如果结构体比较大时会降低代码运行速度),
但是当结构的体积比较大时,则需要来通过传递结构体的地址来提高程序的运行效率。
*/
struct jiegou {//声明一个结构体

string name;
int age;

};
void jiegouhanshu(jiegou t1, jiegou t2) {//传递结构体

cout << t1.name << " "<< t1.age<< " " << "结构体函数传递参数t1" << endl;
cout << t2.name << " " << t2.age<< " " << "结构体函数传递参数t2" << endl;

}
//返回结构体并输出
jiegou fanhuijiegou( jiegou t1 , jiegou t2) {

jiegou f1;
f1.name = t1.name + t2.name;
f1.age = t1.age + t2.age;
return f1;

}
void jiegoushuchu(jiegou k1) {

cout << k1.name << endl;
cout << k1.age << endl;

}
/*
函数的返回值可以是结构,当返回的是结构式需要单独写一个输出函数来输出结构。如果直接输出函数名得到的这个函数的
地址,而不是函数里面的内容。输出返回结构体步骤详见 fanhuijiegou与jiegoushuchu函数。(首先在fanhui结构这个函数
内实例化一个结构,然后返回它,然后创建一个输出函数如jiegoushuchu,将fanhuihanshu的传递式书写进jiegoushuchu
的参数列表如(jiegoushuchu(fanhuijiegou(h1, h2));),这时jiegoushuchu(fanhuijiegou(h1, h2));函数调用的是自身
的返回值,返回值传递给jiegoushuchu函数,jiegoushuchu函数进行输出。最后完成输出动作。)
*/
/*
传递结构地址:
1.传递函数时,将结构的地址(&jiegou)而不是结构本身(jiegou)传递过去。
2.将形参声明为指向结构的指针,即jiegou *类型。由于函数不应该修改结构,因此使用const修饰符。
3.由于形参是指针而不是结构,因此应使用间接成员运算符(->)而不是成员运算符(句点)。

*/

//数组与string
void zifustring(string sa[]) {

cout << sa[2] << endl;
int i = 2;
i = i + 1;
cout << sa[i] << endl;

}

int main() {

//有返回值的函数
cout << "有返回值的函数" << endl;
double x = sqrt(4);
cout << x << endl;

/*
有返回值的函数被调用后将会返回一个值,这个值可以赋给变量或者在其他的表达式中使用。在上面例子中,sqrt()为被调用函数。
x = sqrt()为调用函数,圆括号内的值是参数,将传递给被调用函数。被调用函数在计算出结果后将结果返回给调用函数,返回的值
被成为返回值。(c++程序应当为程序中使用的每个函数提供原型)
*/

//多参函数

cout << "多参函数" << endl;
double a = pow(5.0, 8.0);
cout << a << endl;

/*
在上面的例子里,pow函数需要传输两个参数。这个函数的用处是计算次方数,
第一个参数(5.0)作为底数,第二个参数(8.0)作为指数的幂。
*/

//不需要参数的函数

cout << "不需要参数的函数" << endl;
int b = rand();
cout << b << endl;

/*
在上面的例子中,rand函数不需要任何参数。rand()函数的作用是返回一个随机的整数。
*/

//有返回值的自定义函数输出

cout << "有返回值的自定义函数输出" << endl;
int c = huanshu_2();
cout << c << endl;

//有参无返回值的自定义函数输出

hanshu_3("我是有参无返回值的函数");
cout << endl;

//有参有返回值的自定义函数输出

cout << "有参有返回值的自定义函数输出" << endl;
int d = hanshu_4(5, 6);
cout << d << endl;
cout << endl;

//自定义函数与数组

cout << "自定义函数与数组" << endl;
int arr1[4] = { 1,2,3,4 };
int e = 6;
hanshu_5(arr1, e);//在传递数组时,只需要把数组名填写进去即可。
cout << endl;

//函数与二维数组

int arr2[2][3] = { {1,2,3},{4,5,6} };
int f = 5;
hanshu_6(arr2,f);
cout << endl;

//函数与字符串

char arr3[12] =  "hello world" ;
hanshu_7(arr3);
cout << endl;

//返回字符串数据

cout << "返回字符串数据" << endl;
char arr4 = 'oooo';
cout << hanshu_8(arr4, 4) << endl;
cout << endl;

//函数与结构体

jiegou j1,j2;
cout << "函数与结构体传递结构体输出" << endl;
j1 = { "结构体1",18 };
j2 = { "结构体2",19 };
jiegouhanshu(j1, j2);
cout << endl;

//返回结构体输出

cout << "返回结构输出" << endl;
jiegou h1, h2;
h1 = { "我是结构h1", 18 };
h2 = { "我是结构h2", 19 };
fanhuijiegou(h1, h2);
jiegoushuchu(fanhuijiegou(h1, h2));
cout << endl;

//数组与string

cout << "函数与string输出" << endl;
string se[5] = { "大家好","你好世界","今天过的怎么样","今天很不错","很好" };
zifustring(se);
cout << endl;

}
源文件下载地址:点击下载

文章目录