c++入门到跑路4

函数的调用

语法：函数名(参数)

函数定义小括号内称为形参，函数调用时传入的参数称为实参

值传递

所谓值传递，就是函数调用时实参将数值传入给形参

当我们做值传递时，如果形参发生改变，并不会影响实参

原因：内存地址不同。

函数的常见样式

1.无参无返回值

2.有参无返回值

3.无参有返回值

4.有参有返回值

void f1(){
//无参无返回值
}
void f2(int a,int b){
//有参无返回值
}
int f3(int a,int b){
//有参有返回值
	return 0;
}
int f4(){
//无参有返回值
	return 0;
}

函数的声明

作用：告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义

函数的声明可以多次，但是函数定义只有一次

一般来说函数定义到main函数下面，编译器会找不到你所使用的函数，这个时候我们就要使用函数声明。让编译器提前知道这个函数的存在

你所使用的函数返回值类型 你所使用的函数(参数1，参数2)

#include<iostream>
using namespace std;
int max(int a, int b);//函数声明可以多次
int main()
{
	int a = 10, b = 50;
	cout << max(a,b) << endl;
	system("pause");
	return 0;
}
int max(int a,int b)//函数定义只能一次
{
	return a > b ? a : b;
}

函数的分文件编写

作用：让代码更清晰，更容易维护。

分文件步骤：

1.创建后缀名为.h的头文件

2.创建后缀名为.cpp的源文件

3.在头文件中写函数的声明

4.在源文件中写函数的定义

下面就是一个简单的分文件编写

//main函数中
#include<iostream>
#include"jiaoh.h"
using namespace std;
int main()
{
	jiaoh(10, 50);
	system("pause");
	return 0;
}

头文件中

#include<iostream>
using namespace std;
void jiaoh(int a, int b);

源文件中

#include"jiaoh.h"
void jiaoh(int a,int b)
{
	int temp = a;
	a = b;
	b = temp;
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
}

指针

作用：可以通过指针间接访问内存

内存编号是从0开始记录的，一般用十六进制数字表示

可以利用指针变量保存地址

指针变量的定义和使用

指针变量定义的语法：数据类型 * 变量名；

int *p;
int a = 10;
p = &a;
cout<<"p的指针地址是:"<<p<<endl;

使用指针：可以通过解引用的方式来找到指针指向的内存

指针前加*代表解引用，找到指针指向的内存中的数据。

int *p;
int a = 10;
p = &a;//这也可以写成这样 int *p = &a
cout<<"p的指针地址是:"<<p<<endl;
*p = 999;
cout<<"解引用后的指针数据*p："<<*p<<endl//999
    cout<<"a此时存放数据为："<<a<<endl//999

指针所占内存空间

在32位操作系统下：指针占用4个字节的空间，不管什么数据类型。

在64位操作系统下：指针占用8个字节的空间，不管什么数据类型。

cout << "指针占用空间：" << sizeof(*p) << endl;
	cout << sizeof(char*) << endl;
	cout << sizeof(float*) << endl;
	cout << sizeof(double*) << endl;
	cout << sizeof(bool*) << endl;

上述指针在不同位数操作系统下，指针内存占用是不相同的。

空指针和野指针

空指针：指针变量指向内存中编号为0的空间

用途：初始化指针变量

注意：空指针指向的内存是不可以访问的，0~255之间的内存编号是系统占用的，我们是没有权限进行访问和修改

#include<iostream>
using namespace std;
int main()
{
	int *p = NULL;
	cout << p << endl;//00000000
	system("pause");
	return 0;
}

野指针

指针变量指向非法的内存空间

const修饰指针

const修饰指针有三种情况

1.const修饰指针 --常量指针

2.const修饰常量 --指针常量

3.const即修饰指针又修饰指针

const修饰的指针-常量指针：里面的指向可以修改，但是里面的值不能被修改

const int *p;

const修饰常量 --指针常量:指针指向不能改，指针指向的值可以更改

int *const p = &a

const即修饰指针又修饰指针:指针指向和指针指向的值都不可以修改

const int * const p = &a

#include <iostream>
using namespace std;
int main()
{
	int a = 10, b = 30;
	//第一种const修饰指针 -常量指针，不可以修改值，但可以修改指向。
	const int* p = &a;
	//第二种const修饰常量，-指针常量，不可以修改指向，但可以修改值
	int* const p3 = &a;
	*p3 = 300;
	//p3 = &b;
	//第三种，即修饰指针又修饰常量
	const int* const p2 = &a;
	//p2 = &b;
	//*p2 = 100;
	cout << *p << endl;
	cout << *p2 << endl;
	cout << *p3 << endl;
	system("pause");
	return 0;
}

指针和数组

作用：利用指针访问数组中元素

#include<iostream>
using namespace std;
int main()
{
	int arr[5] = { 1,2,3,5,6 };
	int* p = arr;
	//普通访问
	cout << arr[0] << endl;//1
	//指针访问
	cout << *p << endl;//1
	p++;//访问下一个数组
	cout << *p << endl;//2
	int *p2 = arr;
	for (int i = 0; i < 5; i++)
	{
		cout << *p2 << endl;//通过指针遍历了arr数组
		p2++;
	}
	system("pause");
	return 0;
}

指针和函数

作用：利用指针作函数参数，可以修改实参的值

通过地址传递方式，将地址传过去，如果是地址传递，可以修饰实参，也就是在另一个函数内部修改传过来的实参。

#include<iostream>
using namespace std;
void gay(int* a, int* b);
int main()
{
	int a = 10, b = 20;
	gay(&a, &b);
	system("pause");
	return 0;
}
void gay(int* a, int* b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
	cout << "a:" << *a << endl;
	cout << "b:" << *b << endl;
}