C++之函数，指针

🕗 发布于 2024-03-02 14:51 c++ 开发语言

函数

1，函数概述

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

一个较大的程序，一般分为若干份程序块，每个模块实现特定的功能

2，函数的定义

函数的定义一般有五个步骤：

1，返回值类型

2，函数名

3，参数列表

4，函数体语句

5，return表达式

语法：

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

{

函数体语句；

return 表达式；

}

举例：

#include<iostream>
using namespace std;

//函数的定义
//加法函数，实现两个征信相加，并且将相加的结果返回
int add(int num1, int num2)//定义中的num1,num2称为形参
{
int sum = num1 + num2;
return sum;
}

3，函数的调用

功能：使用定义好的函数

语法：函数名{参数}

示例：

//加法函数，实现两个征信相加，并且将相加的结果返回
int add(int num1, int num2)//定义中的num1,num2称为形参
{
int sum = num1 + num2;
return sum;
}

int main()
{
int a = 10;
int b = 20;
//调用add函数

int c = add(a, b);//调用时的a,b称为实际参数，简称实参
cout << "sum= " << c << endl;
system("pause");
return 0;
}

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

4，值传递

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

值传递的时候，如果形参发生改变不会影响实参

示例：

void swap(int num1, int num2)
{
cout << "交换前" << endl;
cout << "num1= "<<num1 << endl;
cout << "num2= " << num2 << endl;

int temp = num1;
num1 = num2;
num2 = temp;

cout << "交换后" << endl;
cout << "num1= " << num1 << endl;
cout << "num2= " << num2 << endl;

//return：返回值不需要的时候，可以不写return
}

int main()
{
int a = 10;
int b = 20;

cout << "a = " << a << endl;
cout << "b = " << b << endl;

swap(a, b);
//当我们在做值传递的时候，函数的形参发生改变，并不会影响实参
cout << "a = " << a << endl;
cout << "b = " << b << endl;

system("pause");
return 0;
}

5，函数的常见形式

常见的函数形式有四种

1，无参无返

2，有参无返

3，无参有返

4，有参有返

示例：

//函数的样式
//常见的函数形式有四种

//1，无参无返
void test1()
{
cout << "this is test 01" << endl;
}
//2，有参无返
void test2(int a)
{
cout << "this is test 02: " << a << endl;
}
//3，无参有返
int test3()
{
return 10000;
}
//4，有参有返
int test4(int b)
{
cout << "this is test 04:" << b << endl;
return b;
}

int main()
{
//1，无参无返函数调用
test1();

//2，有参无返函数调用
int a = 10;
test2(a);

    //3，无参有返函数调用
int num1=test3();
cout << "test num = " << num1 << endl;

//4，有参有返函数调用
int num4=test4(500);
cout << "num4 = " << num4 << endl;

system("pause");
return 0;
}

int max(int j, int k)
{
return j > k ? j : k;
}

int main()
{
int a = 15;
int b = 35;
int result=max(a, b);
cout << "result = " << result << endl;

system("pause");
return 0;
}

6，函数的声明

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

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

示例：

int max(int j, int k)
{
return j > k ? j : k;
}

int main()
{
int a = 15;
int b = 35;
int result=max(a, b);
cout << "result = " << result << endl;

system("pause");
return 0;
}

首先这是我们常用的函数调用方式

//函数的声明
int max(int j, int k);
int max(int j, int k);
int max(int j, int k);
int max(int j, int k);

//提前告诉编译器函数的存在，可以利用函数的声明
//函数的声明可以多写接触，但是定义只能写一次

int main()
{
int a = 15;
int b = 35;
int result = max(a, b);
cout << "result = " << result << endl;

system("pause");
return 0;
}

//函数的定义
int max(int j, int k)
{
return j > k ? j : k;
}

7，函数的分文件编写

作用：让代码结构更加清晰

函数分文件编写一般有四个步骤：

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

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

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

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

示例：

#pragma once
//hanshu.h文件
#include<iostream>
using namespace std;

//实现寻找最大值
int max(int j, int k);

//函数的使用.cpp文件
void swap(int num1, int num2)
{
cout << "交换前" << endl;
cout << "num1= "<<num1 << endl;
cout << "num2= " << num2 << endl;

int temp = num1;
num1 = num2;
num2 = temp;

cout << "交换后" << endl;
cout << "num1= " << num1 << endl;
cout << "num2= " << num2 << endl;

//return：返回值不需要的时候，可以不写return
}

int main()
{
int a = 10;
int b = 20;

cout << "a = " << a << endl;
cout << "b = " << b << endl;

swap(a, b);
//当我们在做值传递的时候，函数的形参发生改变，并不会影响实参
cout << "a = " << a << endl;
cout << "b = " << b << endl;

system("pause");
return 0;
}

指针

1，指针的基本概念

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

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

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

2，指针变量的定义和使用

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

示例：

#include<iostream>
using namespace std;

int main()
{
//1,定义指针
int a = 10;//定义整型变量
int* p;//定义指针变量

p = &a;//指针指向a的地址
cout << "a的地址为 " << &a << endl;//打印a的地址

cout << "p=" << p << endl;//打印指针变量p

//2，指针的使用
//通过*操作符指针变量指向的内存
cout << "p=" << *p << endl;//p=10
system("pause");
return 0;
}

3，指针所占内存空间

/指针所占内存空间
int main()
{
int a = 10;
int* p;
p = &a;

cout << *p << endl;
cout << sizeof(p) << endl;
cout << sizeof(char*) << endl;
cout << sizeof(int*) << endl;
cout << sizeof(double*) << endl;
cout << sizeof(float*) << endl;

system("pause");
return 0;
}

在64位运行的结果：

在32位环境下运行的结果如下：

总结：在64位操作系统下，指针是占8个字节空间大小，不管是什么数据类型

在32位操作系统下，指针是占4个字节空间大小，不管是什么数据类型

4，空指针和野指针

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

用途：初始化指针变量

注意：空指针指向的内存是不可以访问的

示例1：空指针

//空指针的使用
int main()
{
//1，空指针用于给指针变量进行初始化
int* p = NULL;

//2,空指针是不可以进行访问的
*p = 100;
//访问空指针报错
//内存编号为0~255为系统占用内存，不允许用户访问
system("pause");
return 0;
}

4.2 野指针：空间指向非法的内存空间

示例2：野指针

int main()
{
//指针变量p指向内存地址编号为0x1100的空间
int* p = (int*)0x1100;

//访问野指针报错
cout << *p << endl;
system("pause");
return 0;
}

5，const修饰指针

const修饰针有三种情况：

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

示例：

//const修饰指针--常量指针
int main()
{
int a = 10;
int b = 20;
//const修饰的是指针，指针指向可以改，指针指向的值不能改
const int* p1 = &a;
p1 = &b;
//*p1 = 100;//报错

system("pause");
return 0;
}

总结：int* 放在const右边，表示常量指针

记忆方式：常量指针说明该指针的数值是常量，不可修改，const在int*前边，就说明const修饰的是指针，称为常量指针（仅供记忆方式参考）

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

示例：

//const修饰常量--指针常量
int main()
{
int a = 10;
int b = 20;

//指针的指向不可以修改，指针指向的值可以改
int* const p2 = &a;
*p2 = 100;//正确
//p2 = &b;//报错，指针的指向不能改
system("pause");
return 0;
}

总结：int* 放在const左边，表示指针常量

记忆方式：指针常量说明该指针是常量，说明指针的指向是固定的，不可以修改的，const在int*后边，就说明const修饰的是常量，称为指针常量（仅供记忆方式参考）

3，const修饰指针和常量

//const修饰指针和常量
int main()
{
int a = 10;
int b = 20;

//指针的指向 和指针指向的值 都不可以修改
const int* const p3 = &a;

//*p3 = 100;//错误
//p3=&b;//错误

system("pause");
return 0;
}

6，指针和数组

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

示例：

int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };

int* p = arr;//指向数组的指针

cout << "第一个元素：" << arr[0] << endl;
cout << "指针访问的第一个元素" << *p << endl;
    cout << "利用指针遍历数组" << endl;

for (int i = 0; i < 10; i++)
{
       //cout<<arr[i]<<endl;
cout << *(p+i) << endl;
       //cout << *p << endl;
       //p++;
}
system("pause");
return 0;
}

7，指针和函数

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

7.1值传递

注意：值传递不会改变实参

void swap01(int a, int b)
{
int temp = a;
a = b;
b = temp;
cout << "值传递后：" << endl;
cout << "a= " << a << endl;
cout << "b= " << b << endl;
}

int main()
{
//1，值传递
int a = 10;
int b = 20;
cout << "值传递前：" << endl;
cout << "a= " << a << endl;
cout << "b= " << b << endl;

swap01(a, b);

cout << "值传递后main函数中："<<endl;
cout << "a= " << a << endl;
cout << "b= " << b << endl;
//说明值传递不会改变实参

system("pause");
return 0;
}

7.2地址传递

示例：

注意：地址传递可以改变实参

void swap02(int* p1, int* p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
cout << "值传递后：" << endl;
cout << "a= " << *p1 << endl;
cout << "b= " << *p2 << endl;
}

int main()
{
//1，值传递
int a = 10;
int b = 20;

cout << "值传递前：" << endl;
cout << "a= " << a << endl;
cout << "b= " << b << endl;

swap02(&a, &b);

cout << "值传递后main函数中："<<endl;
cout << "a= " << a << endl;
cout << "b= " << b << endl;
//说明值传递不会改变实参

system("pause");
return 0;
}

8，指针，数组，函数

案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序

示例：

//冒泡排序
void Bubblesort(int * arr, int len)
{
for (int i = 0; i < len-1; i++)
{
for (int j = 0; j < len - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}

}
}
}

void printArray(int* arr, int len)
{
cout << "排序后" << endl;
for (int k = 0; k < len; k++)
{
cout << arr[k] << " ";
}
cout << endl;
}
int main()
{
int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
int len = sizeof(arr) / sizeof(arr[0]);

cout << "排序前" << endl;
for (int k = 0; k < len; k++)
{
cout << arr[k] << " ";
}
cout << endl;

Bubblesort(arr, len);

printArray(arr, len);
system("pause");
return 0;
}

9 练习案例：二分查找函数实现

// 二分查找函数
// array：已排序的数组
// left：搜索范围的开始索引
// right：搜索范围的结束索引
// key：要查找的元素
int binarySearch(int array[], int left, int right, int key) {
while (left <= right) {
int mid = left + (right - left) / 2;

// 检查mid是否是要查找的元素
if (array[mid] == key) {
return mid;
}

// 如果key比mid大，说明它只能在右边的子数组中
if (array[mid] < key) {
left = mid + 1;
}

// 否则，key只能在左边的子数组中
else {
right = mid - 1;
}
}

// 如果元素不存在于数组中
return -1;
}

int main() {
int arr[] = { 1, 3, 5, 7, 9, 11 };
int n = sizeof(arr) / sizeof(arr[0]);
int x = 7;

int result = binarySearch(arr, 0, n - 1, x);

if (result == -1) 
{
cout << "元素未在数组中找到。" << endl;
}
else {
cout << "元素在数组中的索引为: "<<result << endl;
}

return 0;
}

在这个实现中，`binarySearch`函数接受四个参数：

一个整型数组`array`

两个整型索引`left`和`right`定义了搜索的范围，以及一个整型值`key`表示要查找的元素。

函数返回找到的元素的索引，如果没有找到则返回-1。

请注意，在计算中间索引`mid`时，使用`left + (right - left) / 2`而不是`(left + right) / 2`是为了防止在`left`和`right`很大时导致整数溢出。

原文地址：https://blog.csdn.net/bai_lan_ya/article/details/136393155

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：echarts vue 动画效果的水球图、波浪图教程
下一篇：C++异常_C++回顾

leetcode289:生命游戏
根据，简称为，是英国数学家约翰·何顿·康威在 1970 年发明的细胞自动机。给定一个包含m × n个格子的面板，每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态：1即为（live），或0即为
阅读更多2024-10-20
MongoDB数据恢复
注意：两个MongoDB的版本要一致，本文使用的是mongo:4.2.24。先把K8S上面的MongoDB 容器停止（可以把副本改成0）。1、将容器挂载MongoDB的数据目录备份到本地。经常是数据文
阅读更多2024-10-20
C#中实现事务
C#中实现事务
阅读更多2024-10-20
【LeetCode每日一题】——560.和为 K 的子数组
给你一个整数数组 nums 和一个整数 k ，请你统计并返回该数组中和为 k 的子数组的个数。子数组是数组中元素的连续非空序列。
阅读更多2024-10-20
「漏洞复现」满客宝智慧食堂系统 selectUserByOrgId 未授权访问漏洞
请勿利用文章内的相关技术从事非法测试，由于传播、利用此文所提供的信息而造成的任何直接或者间接的后果及损失，均由使用者本人负责，作者不为此承担任何责任。工具来自网络，安全性自测，如有侵权请联系删除。本次
阅读更多2024-10-20
React面试题目（从基本到高级）
React前端面试常见题目涵盖了React的基础概念、组件、状态管理、生命周期、性能优化等多个方面。
阅读更多2024-10-20
12.个人博客系统（Java项目基于spring和vue）
1 在校学习的学生，可用于日常学习使用或是毕业设计使用 2 毕业一到两年的开发人员，用于锻炼自己的独立功能模块设计能力，增强代码编写能力。 3 亦可以部署为商化项目使用。 4 需要完整资料及源码
阅读更多2024-10-20
YoloV8改进策略：注意力改进|DeBiFormer，可变形双级路由注意力|引入DeBiLevelRoutingAttention注意力模块（全网首发）
本次改进的核心在于将DeBiLevelRoutingAttention模块嵌入到YoloV8的主干网络中，具体位置是在SPPF（Spatial Pyramid Pooling Fast）模块之后。这一
阅读更多2024-10-20
word取消自动单词首字母大写
情况说明：在word输入单词后首字母会自动变成大写取消单词首字母大写步骤：（1）点击菜单栏文件（2）点击“更多”——>“选项”（3）点击“校对”——>“自动更正选项”（4）取消“句首字母大
阅读更多2024-10-20
web前端网页用户注册页面
【代码】web前端网页用户注册页面。
阅读更多2024-10-20

C++之函数，指针

函数

1，函数概述

2，函数的定义

3，函数的调用

4，值传递

5，函数的常见形式

6，函数的声明

7，函数的分文件编写

指针

1，指针的基本概念

2，指针变量的定义和使用

3，指针所占内存空间

4，空指针和野指针

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

4.2 野指针：空间指向非法的内存空间

5，const修饰指针

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

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

3，const修饰指针和常量

6，指针和数组

7，指针和函数

7.1值传递

7.2地址传递

8，指针，数组，函数

9 练习案例：二分查找函数实现

相关文章