目录

一、函数

1、一些基本概念

2、函数的声明

3、函数的分文件编写

4、函数可设置默认参数

5、函数的占位参数

6、函数的重载

二、指针

1、基本概念：

2、指针的定义和赋值

3、指针占用的内存空间

4、const修饰指针

5、指针与数组的关系

6、指针和普通变量作为函数参数的区别

7、空指针

8、野指针

三、引用(一种不能修改指向的指针)

1、基本概念：

2、应用的定义和赋值

3、引用作为函数此参数

4、引用作为函数的返回值

5、const修饰引用

四、结构体

1、基本概念：

2、结构体的定义和赋值：

3、在结构体中嵌套结构体

4、结构体作为函数的参数

5、const修饰结构体

前言：学习资料参考自《C++ Primer Plus(第6版)中文版》和B站视频《C++教程从0到1入门编程》黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难_哔哩哔哩_bilibili

• 函数概述：将一段经常使用的代码封装起来，减少重复
• 函数的定义语法：

  返回类型  函数名（参数列表）

{

              主体语句

       return 返回的语句

}

//例子：函数的定义
int add(int num1,int num2)
{
    int sum=sum1+sum2;
    return sum;
}

• 调用函数：使用定义好的函数

格式：函数名（参数）

//例子：函数的调用
int a=1,b=2;
int c=add(a,b);//调用已经定义过的函数

• 形参与实参

  形参：形式上的参数，函数定义的参数，非真实使用的数据。

  实参：实际参数，函数调用时，实参的值会传递到形参中。

//函数定义
int add(int num1,int num2)//此处的num1,num2称为形参
{
    int sum=sum1+sum2;
    return sum;
}
//函数调用
int a=1,b=2;
int c=add(a,b);//此处的a,b称为实参

• 参数有无和返回有无

  根据参数、返回有无分为4种形式：无参无返，无参有返，有参有返，有参无返

• 作用：告诉编译器该函数的存在及如何调用，函数的实际主体可单独定义。(编译器要知道函数的存在才能调用,这样定义可以放在调用后面写。)
• 用法：可多次声明，多次调用。但函数的定义只能有1次。

//声明
int max(int a,int b);
//调用
int aa=1,bb=2;
max(aa,bb)
//定义
int min(int a,int b)
{
    return a>b?a:b;
}

分文件编写的意义：将函数封装到头文件，就可在其他文件调用该函数，增加函数的可复用性。

  步骤：

1. 创建头文件：.h后缀
2. 创建源文件：.cpp后缀
3. 在头文件中写函数声明和定义
4. 在源文件声明头文件，调用函数

//例子：函数的分文件写法

//先新建以下.h头文件,如文件命名为sawp.h
#includeusing namespace std;
void swap(int a,int b)
{
    int temp=a;
    a=b;
    a=temp;
    cout<<"a="<
using namespace std;
#include"swap.h"//声明头文件
int main
{
    int a=1,b=2;
    swap(a,b);//调用头文件中的函数
    system("pause");
    return 0;
}

用法：

• 默认参数要放在后面，不能出现后面没默认参数的情况。
• 只能声明或定义时的其中一种情况写，不能同时都写默认参数

//函数调用的例子
void swap(int a,int b=111,int c=999);//声明，b和c设置了默认参数
//函数调用
int main()
{
    swap(10,20);//参数c使用了默认参数
    return 0;
}
//函数定义
//void swap(int a,int b,int c)//前面声明时已有设置默认参数，故此处定义时不允许设置默认参数
{
    cout<

//使用占位参数例子
void F(int)//无默认参数的占位参数
{
    cout<<1<

//函数重载的例子
void F(int &a)
{
}
void F(const int &a)//重载
{
}

//调用以上函数
void main1()
{
    int a=10;
    F(0);//调用F(const int &a）
    F(a);//调用F(int &a)
}
//
void A(int a)
{
}
void A(int a,int b=10)//含有默认参数的重载
{
}
void main2()
{
    A(10);//此处有二义性，编译器会报错。应避免含有默认参数的重载
}

int *p;//定义了一个指针
int a=10;//定义一个变量
p=&a;//对指针赋变量a的地址
*p=1000;//改变了a的内容
cout<<*p<

//查看指针内存大小
int a=10;
int *p=&a;//定义一个指针
cout<

//const修饰指针的3种情况
int a=1,b=2;//定义两个变量

//const修饰指针
const int *p1=&a;//常量指针（指向的内容不可修改，指向的地址可修改）
p1=&b;//指向地址可改，若*p1=20;则会报错，因为指向的内容不可修改

//const修饰常量
int const *p2=&a;//指针常量（指向的内容可修改，指向的地址不可修改）
*p2=20;//指向的内容可改，若p2=&b;则会报错，因为指向地址不可修改

//const修饰常量
const int const *p3=&a;//指向的内容可和地址都不可修改
//p3=&b;和*p3=20;均会报错

int arr[10]={0,1,2,3,4,5,6,7,8,9}//定义一个数组
int *p=arr;//指向数组的首地址
p=arr[0];//还是指向数组的首地址
p++;//指向下一个，即arr[1]

//针和普通变量作为函数参数的区别

void swap01(int a,int b)//普通变量传参
{
    int temp =a;
    a=b;
    b=temp;
}

void swap02(int *p1,int *p2)//指针传参
{
    int temp =*p1;
    *p1=*p2;
    *p2=temp;
}
//应用
int main()
{
    int a=1,b=2;
    swap01(a,b);//只复制了数值传进去，此时a,b并没有被修改
    swap02(&a,&b);//传入地址，此时a,b已被修改
}

//用空指针初始化指针
int *p=NULL;

//野指针的例子
int *p=(int *)0X1100//没申请的内存空间，p是个野指针
cout<<*p<

//定义和使用引用
int a=1;//定义一个变量
int &b=a;//定义一个引用，且初始化
b=10;//间接对a进行操作,此时a=10

//引用作为函数参数的例子
void swap(int &a,int &b)//引用作为参数，效果跟指针一样，但代码简洁
{
    int temp=a;
    a=b;
    b=temp;
}
//应用
void main()
{
   int a=1,b=2;
    swap(a,b);//直接填入即可，不需先将变量转化为地址或指针填入
}

//引用作为函数的返回值
int &test()
{
    static int a=10;//定义一个静态变量，属于全局变量，所以不会被释放
    return a;//作为a的引用返回
}
//调用
void main()
{
    int &ref=test();//定义一个引用，指向a
    test()=100;//函数的调用可以作为左值，因为函数返回是引用，相当于一个变量。
                //同时静态变量a也被修改了
    cout<

//const修饰传参中的引用
void showValue(const int &val)
{
    cout<

//创建和使用结构体

struct student//定义一个名为student的结构体类型
{
    int age;
    int height;
    string name;
}

student Amy={27,158,"艾米"}//创建具体的student类型结构体
coutage=80;//修改成员

struct teacher//定义1个结构体
{
    int age;
    string name;
}

struct student//定义1个结构体
{
    int age;
    int height;
    string name;
}

struct school//使用以上结构体
{
    struct teacher t1;
    struct teacher t2;
    struct student s1;
    struct student s2;
    struct student s3;

}

//创建具体的结构体
school MIT=
{
    {38,"IP MAN"},
    {40,"Jacky Chan"},
    {12,160,"A"},
    {13,158,"B"},
    {14,162,"C"},
}
//访问
cout<

struct student//定义1个结构体
{

}
//结构体出现在函数中
void printStudent1(struct student s);//声明1个函数，值传递
void printStudent2(struct student *s);//声明1个函数，地址传递

struct student s1;

//调用
printStudent1(s1);//复制实参的数据到函数
printStudent1(&s1);//在函数里直接操作实参

//结构体使用const,防止被修改

struct student//定义1个结构体
{
    int age;
    int height;
    string name;
}

void printStudent(const student *S)//定义一个函数访问结构体，使用const防止结构体被修改
{
    cout<name<