C++笔记5-函数/指针/结构体

函数

函数作用
将一段经常使用的代码封装起来，减少重复编码。

函数的定义

函数的5个步骤

• 返回值类型
• 函数名
• 参数列表
• 函数体语句
• return 表达式

需要注意：
1、函数形参改变不影响实参
2、函数的几种基本样式（无参无反、无参有反、有参无反、有参有反）
3、函数声明能写多次，但是定义只能写一次

函数的分文件编写
让代码结构更加清晰
分文件编写步骤

1. 创建后缀名为.h的头文件
2. 创建后缀名为.cpp的源文件
3. 在头文件写函数的声明
4. 在源文件中写函数的定义

函数份文件Demo：
1、主调用函数 main.h

#include<iostream>
#include "add.h"   //双引号表示自定义头文件 
using namespace std;

int main(){
	int a=1,b=2;
	cout<<add(a,b)<<endl;
	system("pause");
	return 0;
}

2、被调函数头文件add.h

#include<iostream>
using namespace std;

int add(int num1,int num2){
	return num1+num2;
}

指针

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

指针的定义和使用

指针变量定义语法：
数据类型 * 变量名;
下面是在函数中交换两个整形变量值的Demo

void exchange(int *a,int *b){
	int temp=*a;   //指针前加*表示解引用，即找到指针指向的数据单元的内容 
	*a=*b; 
	*b=temp;
}

int main(){
	int a=10,b=20;
	int * pa=&a,*pb=&b ;
	cout<<"a="<<a<<"\tb="<<b<<endl;
	exchange(pa,pb);
	cout<<"a="<<a<<"\tb="<<b<<endl;
	system("pause");
	return 0;
}

指针所在的内存空间
32位操作系统：4个字节
64位操作系统：8个字节

	cout<<"指针变量所占的内存空间="<<sizeof(double*)<<endl; 

空指针
指针变量指向内存中编号为0的空间
空指针指向的内存是不可以访问的

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

空指针和野指针都不是我们申请的内存空间，因此尽量不要访问

const修饰指针
const修饰指针有三种情况

• const修饰指针——常量指针

const int *p;

指针的指向可以修改，但是指针指向的值不可以修改

	int a=10,b=20,c=30;
	const int * pa=&a,*pb=&b ; //常量指针的指向可以改变，但指针指向的值不能改变 
	cout<<"a="<<*pa<<"\tb="<<*pb<<endl;
	//exchange(pa,pb);
	pa=&c;  //改变常量指针的指向 ，可实现 
	//*pa=a; 改变常量指针内的值，不可实现 
	cout<<"a="<<*pa<<"\tb="<<*pb<<endl;

• const修饰常量——指针常量

int * const p;

指针的指向不可以改，但指针指向的值可以改

	int a=10,b=20,c=30;
	int * const pa=&a,*pb=&b ; //指针常量的指向不可以改变，但指针指向的值可以改变 
	cout<<"a="<<*pa<<"\tb="<<*pb<<endl;
	//exchange(pa,pb);
	//pa=&c;  改变指针常量的指向 ，不可实现 
	*pa=c; //改变指针常量内的值，可实现 
	cout<<"a="<<*pa<<"\tb="<<*pb<<endl;

• const既修饰指针，又修饰常量

const int *const p;

指针的指向和指针指向的值都不能修改

指针和数组
利用指针访问数组中的元素

	int a[]={1,2,3,4,5,6,7,8,9,10};
	int b[3][3]={{11,12,13},{21,22,23},{31,32,33}};
	int * pa=a;
	int * pb=&b[0][0];
	int na=sizeof(a)/sizeof(a[0]);
	int nb=sizeof(b)/sizeof(b[0][0]);
	int b_row=sizeof(b)/sizeof(b[0]);
	int b_col=nb/b_row;
	for(int i=0;i<na;i++){
		cout<<*(pa+i)<<"\t";
	}
	for(int i=0;i<nb;i++){
		if(i%3==0){
			cout<<endl;
		}
		cout<<*(pb+i)<<"\t";
	}
	cout<<endl;

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

void multi(int *p,int n){
	for(int i=0;i<n;i++){
		*(p+i)*=2;
	}
}

void output(int*p,int n){
	for(int i=0;i<n;i++){
		cout<<*(p+i)<<"\t";
	}
	cout<<endl;
}

int main(){
	int a[]={1,2,3,4,5,6,7,8,9,10};
	int a_size=sizeof(a)/sizeof(a[0]);
	int *p=&a[0];
	multi(p,a_size);
	output(p,a_size);
	system("pause");
	return 0;
}

冒泡排序Demo

void bubble_sort(int *p,int size){  //冒泡排序函数 （升序） 
	for(int i=0;i<size;i++){
		for(int j=i+1;j<size;j++){
			if(*(p+i)>*(p+j)){
				int temp=*(p+i);
				*(p+i)=*(p+j);
				*(p+j)=temp;
			}
		}
	}
}

void outPut(int *p,int size){  //输出函数 
	for(int i=0;i<size;i++){
		cout<<*(p+i)<<"\t";
	}
	cout<<endl;
}

int main(){
	int a[]={12,54,22,8,0,343,6,7};
	int size=sizeof(a)/sizeof(a[0]);
	int *p=a;
	outPut(p,size);
	bubble_sort(p,size);
	outPut(p,size);
	system("pause");
	return 0;
}

结构体

基本概念
属于用户自定义的数据类型，允许用户存储不同的数据类型

结构体的定义和使用
struct 结构体名{
结构体成员列表
};
通过结构体创建变量的方式用三种：

• struct 结构体名 变量名

struct student{  //学生结构体 
	string name;
	int age;
	char sex;
	int score[3];
};
int main(){
	struct student s1={
		"张三",20,'M',{93,87,95}
	};
	cout<<"姓名："<<s1.name<<"\n年龄："<<s1.age<<"\n性别："<<s1.sex<<
		  "\n语文："<<s1.score[0]<<"\n数学："<<s1.score[1]<<
		  "\n英语："<<s1.score[2]<<endl; 
	system("pause");
	return 0; 
}

• struct 结构体名 变量名={成员1值，成员2值…}
• 定义结构体时顺便创建变量

结构体数组

int main(){
	student stu[]={
		{"张三",20,'M',{93,87,95}},
		{"李四",22,'L',{100,89,88}},
		{"王五",21,'M',{87,97,99}}
	};
	int n=sizeof(stu)/sizeof(stu[0]);
	for(int i=0;i<n;i++){
			cout<<"姓名："<<stu[i].name<<"\t年龄："<<stu[i].age<<"\t性别："<<stu[i].sex<<
		  "\t语文："<<stu[i].score[0]<<"\t数学："<<stu[i].score[1]<<
		  "\t英语："<<stu[i].score[2]<<endl; 
	}

结构体指针

struct student stu={"张三",20,'M'}；
student * p=&stu;
cout<<"姓名："<<p->name<<endl;  //用结构体指针调用结构体属性时使用->符号

结构体嵌套

struct score{  //学科结构体 
	int Chinese;
	int Math;
	int English;
};

struct student{  //学生结构体 
	string name;
	int age;
	char sex;
	score sco;
};