C++学习笔记（2）——基础2：函数、指针、引用、结构体-创新互联

创新互联服务项目包括淄川网站建设、淄川网站制作、淄川网页制作以及淄川网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，淄川网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到淄川省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！

一、函数

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

一、函数 1、一些基本概念

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

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

{

主体语句

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种形式：无参无返，无参有返，有参有返，有参无返

2、函数的声明

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

3、函数的分文件编写

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

步骤：

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

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

//先新建以下.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;
}

4、函数可设置默认参数

用法：

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

//函数调用的例子
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<

5、函数的占位参数概述：占位参数，只占用位置，不参与操作。也可设置默认参数
//使用占位参数例子
void F(int)//无默认参数的占位参数
{
    cout<<1<
6、函数的重载  概述：相同的函数名可定义新的内容，提高函数的复用性
  重载条件：
同1个作用域（如在同一个上级函数里，同一个类里......）
函数名相同
函数形参的类型、个数或顺序不同。(返回值类型不同是不属于重载)
注意：应尽量避免含有默认参数，容易出现二义性。参数含有引用时，int &和const int &算重载。
//函数重载的例子
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);//此处有二义性，编译器会报错。应避免含有默认参数的重载
}二、指针 
1、基本概念：指针是一种变量类型，用来存放地址（内存编号从0开始记录，一般用16位进制数表示），可以通过指针间接访问内存。
2、指针的定义和赋值定义指针：数据类型 *指针变量名；
赋值：  指针变量名=&变量；
读取或操作指针指向的内容（解引用）：* 指针变量名
读取变量的地址：&变量;
int *p;//定义了一个指针
int a=10;//定义一个变量
p=&a;//对指针赋变量a的地址
*p=1000;//改变了a的内容
cout<<*p<
3、指针占用的内存空间32位系统：4字节
64位系统：8字节
//查看指针内存大小
int a=10;
int *p=&a;//定义一个指针
cout<
4、const修饰指针  在定义时，const修饰指针的3种情况：
const 数据类型 *指针变量名：不能修改指向的内容，但可以修改指向的地址。（内容只读，地址可改）
数据类型 * const 指针变量名：可以修改指向的内容，但不能修改指向的地址。（内容可改，地址不能改）
const 数据类型 * const 指针变量名：指向的地址和内容都不可修改。（内容只读，地址不可改）
//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;均会报错
5、指针与数组的关系  数组名就是数组的首地址，所以数组名相当于指针。
int arr[10]={0,1,2,3,4,5,6,7,8,9}//定义一个数组
int *p=arr;//指向数组的首地址
p=arr[0];//还是指向数组的首地址
p++;//指向下一个，即arr[1]
6、指针和普通变量作为函数参数的区别普通变量传参：只传递值进去函数，没修改变量本身，相当于复制变量。
指针传参：传递地址进去函数，修改了指向的变量 。
//针和普通变量作为函数参数的区别

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已被修改
}
7、空指针概述：空指针指向编号为0的空间
用途：给指针变量初始化
注意：空指针不可访问（0-255之间的内存编号是系统占用，不可访问）
//用空指针初始化指针
int *p=NULL;
8、野指针  野指针：指向非法的内存空间。要避免使用，不能访问。
//野指针的例子
int *p=(int *)0X1100//没申请的内存空间，p是个野指针
cout<<*p<
三、引用(一种不能修改指向的指针) 
1、基本概念：变量的别名：不能改变指向，只能修改指向的内容。
本质：是不能改变指向的指针，相当于 数据类型 * const 指针变量名。
作用：作为变量的别名，在一些场合比用指针表示要简洁。
2、应用的定义和赋值格式：数据类型 &引用名=变量名
注意：必须在初始化时赋值，且初始化后不能更改
//定义和使用引用
int a=1;//定义一个变量
int &b=a;//定义一个引用，且初始化
b=10;//间接对a进行操作,此时a=10
3、引用作为函数此参数  优点：简化指针，使代码简洁明了。效果的等同指针作为函数参数。
//引用作为函数参数的例子
void swap(int &a,int &b)//引用作为参数，效果跟指针一样，但代码简洁
{
    int temp=a;
    a=b;
    b=temp;
}
//应用
void main()
{
   int a=1,b=2;
    swap(a,b);//直接填入即可，不需先将变量转化为地址或指针填入
}
4、引用作为函数的返回值函数返回值为引用，则调用可以作为左值。
注意：引用不能返回局部变量，因为函数结束调用后，局部变量的内存会被释放。
//引用作为函数的返回值
int &test()
{
    static int a=10;//定义一个静态变量，属于全局变量，所以不会被释放
    return a;//作为a的引用返回
}
//调用
void main()
{
    int &ref=test();//定义一个引用，指向a
    test()=100;//函数的调用可以作为左值，因为函数返回是引用，相当于一个变量。
                //同时静态变量a也被修改了
    cout<
5、const修饰引用  当引用作为函数的形参，用const修饰，使形参只读，防止形参被修改。等效于（const 数据类型 * const 指针变量名）。
//const修饰传参中的引用
void showValue(const int &val)
{
    cout<
四、结构体 
1、基本概念：结构体是用户自定义的数据类型，可储存不同数据类型的变量。
2、结构体的定义和赋值：定义：struct 结构体名称{成员列表}
实例化和赋值：结构体名 具体名称={成员1，成员2，......}
创建结构体数组：结构体名 具体名称[长度]={{成员1}，{成员2}，......}
使用指针访问结构体： 通过->操作符访问结构体成员
//创建和使用结构体

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

student Amy={27,158,"艾米"}//创建具体的student类型结构体
coutage=80;//修改成员
3、在结构体中嵌套结构体  在结构体中，可以使用其他结构体作为成员
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<
4、结构体作为函数的参数值传递：传入结构体变量，复制一份数据，不操作原结构体。
地址传递：传入结构体指针，直接操作原结构体。
struct student//定义1个结构体
{

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

struct student s1;

//调用
printStudent1(s1);//复制实参的数据到函数
printStudent1(&s1);//在函数里直接操作实参
5、const修饰结构体作用：防止误操作
用法：使其变成常量指针，const 结构体名*指针名（可指向不同的结构体，但不可改内容）
//结构体使用const,防止被修改

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

void printStudent(const student *S)//定义一个函数访问结构体，使用const防止结构体被修改
{
    cout<name<
你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧
                

                当前标题：C++学习笔记（2）——基础2：函数、指针、引用、结构体-创新互联                

                网址分享：http://ybzwz.com/article/ceehpp.html


        
            其他资讯
            
                
                        中文.网址域名是什么意思，有哪些作用？
                    

                        建设门户网站价格一般需要多少钱？
                    

                        怎么注册美国域名注册域名要注意什么
                    

                        商标如何注册，商标的意义
                    

                        ipv4地址格式是怎样的？如何解决ipv4无网络访问权限问题？