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、函数的分文件编写

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

  步骤:

  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;
}
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. 同1个作用域(如在同一个上级函数里,同一个类里......)
  2. 函数名相同
  3. 函数形参的类型、个数或顺序不同。(返回值类型不同是不属于重载)
  4. 注意:应尽量避免含有默认参数,容易出现二义性。参数含有引用时,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://bzwzjz.com/article/ceehpp.html