C++基础——10-指针

最新推荐文章于 2023-06-21 00:43:01 发布
最新推荐文章于 2023-06-21 00:43:01 发布
阅读量807 收藏 1
点赞数
分类专栏： C++基础 文章标签： c++ 指针 数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daker_huang/article/details/121364443
版权

文章目录

指针

1 指针的基本概念

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

  1. 内存编号是从0开始记录的，一般用用16进制数字表示
  2. 可以利用指针变量保存地址
    在这里插入图片描述

2 指针的变量定义和使用

指针变量定义语法：数据类型 *变量名；
代码示例：
1、指针就是地址；
2、指针可以访问内存地址所对应的值，也可以修改该值

int main()
{
	//1、如何定义指针
	
	int a = 10;
	//指针定义的语法：数据类型 *指针变量名;
	int* p;
	//让指针记录变量a的地址
	p = &a;//取a的地址，指针p记录这个地址
	cout << "a的地址是:" << &a<<endl;
	cout << "指针p=" << p << endl;
	//2、使用指针
	//可以通过解引用的方式来找到指针指向的内存
	//指针前加"*"代表解引用，找到指针指向的内存中的数据
	cout<<"=======================" << endl;
	*p = 1000;//可以修改内存指向的值
	cout << "a=" << a << endl;
	cout << "*p=" << *p << endl;



	return 0;

}

结果：
在这里插入图片描述

3 指针所占内存空间

提问：指针也是一种数据类型，那么，它占了多少内存空间？

int main()
{
	//指针所占空间
	int a = 10;
	int* p = &a;
	//在32为操作系统下，指针都是占4个字节大小，不管是什么数据类型。在64位操作系统下，指针都是占8个字节大小，不管是什么数据类型。
	cout << "sizeof int * =" <<sizeof(p) <<endl;
	cout << "sizeof float * =" << sizeof(float*) << endl;
	cout << "sizeof double * =" << sizeof(double*) << endl;
	cout << "sizeof char * =" << sizeof(char*) << endl;


	return 0;

}

结果：
64为操作系统：
在这里插入图片描述
32位操作系统：
在这里插入图片描述
结论：不管是什么数据类型，在32为操作系统下，指针都是占4个字节大小，在64位操作系统下，指针都是占8个字节大小。

4 空指针和野指针

空指针：指针变量指向内存中编号为0的空间
用途：初始化指针变量
注意：空指针指向的内存是不可以访问的

代码示例：
空指针是不可以进行访问的

	//1、初始化指针变量
	 int* p = NULL;
	//2、空指针是不可以进行访问的
	 *p = 100;

假设定义了一个空指针，然后解引用，将空指针所在地址的值变成100，则会报警告：
在这里插入图片描述
运行时则会报错：
在这里插入图片描述

野指针：指针变量指向非法的内存空间
代码示例：

	//指针变量p指向内存地址编号为0x1100的地址
	//在程序中，尽量避免出现野指针
	int* p = (int *)0x1100;
	cout << *p << endl;

结果：
在这里插入图片描述
总结：空指针和野指针都不是我们申请的空间，因此不要访问

5 const修饰指针

const修饰有3种情况：

  1. const修饰指针 —常量指针
  2. const修饰常量 —指针常量
  3. const既修饰指针，又修饰常量

1、常量指针
常量指针的指向可以改，但指针指向的值不可以改。
在这里插入图片描述

代码示例：

	//1 、const修饰指针 常量指针
	int a = 10;
	int b = 10;
	//指针指向的值不可以改变，但指向可以改变
	const int* p = &a;
	//*p=20; //错误
	p = &b;

	//2、const修饰常量 指针常量
	//指针的指向不可以改，指针指向的值可以改
	int* const p2 = &a;
	*p2 = 100; //正确
	//p2 = &b;//错误，指针指向不可以改

	//3、const修饰指针和常量
	const int* const p3 = &a;
	//指针指向和常量都不可以改
	//*p3 = 100;//错误
	//p3 = &b;//错误

6 指针和数组

作用：利用指针访问数字中的元素
代码示例：

	//利用指针访问数组中的元素
	int arr[] = {1,2,3,4,5,6,7,8,9,10};
	cout << "第一个元素为:"<<arr[0] << endl;
	int* p = arr;//利用指针指向数组名，arr就是数组首地址
	//利用指针来访问数组第一个元素
	cout << "指针访问的第一个元素为:" << *p << endl;
	p++;//指针会往后+4个字节，就会到第二个元素
	cout << "指针访问的第二个元素为:" << *p << endl;
	cout << "for循环指针遍历数组：" << endl;
	int* p2 = arr;
	for (int i = 0; i < 10; i++)
	{
		cout << *p2 << " ";
		p2++;
	}
	cout << endl;

结果：
在这里插入图片描述

7 指针和函数

作用：利用指针作函数参数，可以修改实参的值
        之前有一节我们说过，形参不会改变实参的值，但是，在指针中，形参可以改变实参的值。
代码示例：

//指针和函数
void swap001(int a,int b) //2个数字交换，值传递
{
	int temp = a;
	a = b;
	b = temp;
}
void swap002(int *p1, int *p2) //2个数字交换，地址传递
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
void value_swap()
{
	//1、值传递
	int a = 10;
	int b = 20;
	swap001(a, b);
	cout << "a= " << a << endl;
	cout << "b= " << b << endl;//实参不会发生改变
	cout << "============="<<endl;
	//2、地址传递
	swap002(&a, &b);
	cout << "a= " << a << endl;
	cout << "b= " << b << endl;//实参a和b发生了改变

}

结果：
在这里插入图片描述

8 指针、数组和函数的小案例

描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序
例如数组 int arr[10]={4,3,6,9,1,2,10,8,7,5};
代码示例：

//指针、数组和函数的小案例
	//步骤：
	//1、创建数组
	//2、创建函数实现冒泡排序
	//3、打印排序后的数组

//2、冒泡排序函数创建
//参数1 数组首地址，参数2 数组长度
void bubblesort(int * arr,int len)
{
	for (int i = 0; i < len-1; i++)
	{
		for (int j = 0; j < len - i - 1; j++)
		{
			//如果j>j+1的值，交换数字
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}

}
//3、打印数组
void print_arr(int* arr, int len)
{
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}
void case_point_array_func() {
	//1、创建数组
	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
	// 数组长度
	int len = sizeof(arr) / sizeof(arr[0]);
	//2、冒泡排序函数创建
	bubblesort(arr, len);
	//3、打印数组
	print_arr(arr, len);
	
}

结果：
在这里插入图片描述
本章所有代码：

#include<iostream>
#include<string>
using namespace std;

//指针定义
void point_define()
{

	//1、如何定义指针

	int a = 10;
	//指针定义的语法：数据类型 *指针变量名;
	int* p;
	//让指针记录变量a的地址
	p = &a;//取a的地址，指针p记录这个地址
	cout << "a的地址是:" << &a << endl;
	cout << "指针p=" << p << endl;
	//2、使用指针
	//可以通过解引用的方式来找到指针指向的内存
	//指针前加"*"代表解引用，找到指针指向的内存中的数据
	cout << "=======================" << endl;
	*p = 1000;//可以修改内存指向的值
	cout << "a=" << a << endl;
	cout << "*p=" << *p << endl;


}
//指针所占内存空间
void point_space()
{
	//指针所占空间
	int a = 10;
	int* p = &a;
	//在32为操作系统下，指针都是占4个字节大小，不管是什么数据类型。在64位操作系统下，指针都是占8个字节大小，不管是什么数据类型。
	cout << "sizeof int * =" <<sizeof(p) <<endl;
	cout << "sizeof float * =" << sizeof(float*) << endl;
	cout << "sizeof double * =" << sizeof(double*) << endl;
	cout << "sizeof char * =" << sizeof(char*) << endl;
}
//空指针
void null_point()
{
	
	
	//1、初始化指针变量
	 int* p = NULL;
	//2、空指针是不可以进行访问的,因为0-255之间的内存编号是系统占用的，不可以访问
	 *p = 100;
	 //cout<<*p<<endl;


}
//野指针
void wild_point()
{
	//指针变量p指向内存地址编号为0x1100的地址
	//在程序中，尽量避免出现野指针
	int* p = (int *)0x1100;
	cout << *p << endl;

}
// const 指针常量、常量指针
void const_point()
{
	//1 、const修饰指针 常量指针
	int a = 10;
	int b = 10;
	//指针指向的值不可以改变，但指向可以改变
	const int* p = &a;
	//*p=20; //错误
	p = &b;

	//2、const修饰常量 指针常量
	//指针的指向不可以改，指针指向的值可以改
	int* const p2 = &a;
	*p2 = 100; //正确
	//p2 = &b;//错误，指针指向不可以改

	//3、const修饰指针和常量
	const int* const p3 = &a;
	//指针指向和常量都不可以改
	//*p3 = 100;//错误
	//p3 = &b;//错误



}
//利用指针访问数组中的元素
void point_array() {
	
	int arr[] = {1,2,3,4,5,6,7,8,9,10};
	cout << "第一个元素为:"<<arr[0] << endl;
	int* p = arr;//利用指针指向数组名，arr就是数组首地址
	//利用指针来访问数组第一个元素
	cout << "指针访问的第一个元素为:" << *p << endl;
	p++;//指针会往后+4个字节，就会到第二个元素
	cout << "指针访问的第二个元素为:" << *p << endl;
	cout << "for循环指针遍历数组：" << endl;
	int* p2 = arr;
	for (int i = 0; i < 10; i++)
	{
		cout << *p2 << " ";
		p2++;
	}
	cout << endl;
}
//指针和函数
void swap001(int a,int b) //2个数字交换，值传递
{
	int temp = a;
	a = b;
	b = temp;
}
void swap002(int *p1, int *p2) //2个数字交换，地址传递
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
void value_swap()
{
	//1、值传递
	int a = 10;
	int b = 20;
	swap001(a, b);
	cout << "a= " << a << endl;
	cout << "b= " << b << endl;//实参不会发生改变
	cout << "============="<<endl;
	//2、地址传递
	swap002(&a, &b);
	cout << "a= " << a << endl;
	cout << "b= " << b << endl;//实参a和b发生了改变

}
//指针、数组和函数的小案例
	//步骤：
	//1、创建数组
	//2、创建函数实现冒泡排序
	//3、打印排序后的数组

//2、冒泡排序函数创建
//参数1 数组首地址，参数2 数组长度
void bubblesort(int * arr,int len)
{
	for (int i = 0; i < len-1; i++)
	{
		for (int j = 0; j < len - i - 1; j++)
		{
			//如果j>j+1的值，交换数字
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}

}
//3、打印数组
void print_arr(int* arr, int len)
{
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}
void case_point_array_func() {
	//1、创建数组
	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
	// 数组长度
	int len = sizeof(arr) / sizeof(arr[0]);
	//2、冒泡排序函数创建
	bubblesort(arr, len);
	//3、打印数组
	print_arr(arr, len);
	
}
int main()
{
	//point_define();
	//point_space();
	//null_point();
	//wild_point();
	//const_point();
	//point_array();
	//value_swap();
	case_point_array_func();
	return 0;

}
风极_陨
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
指针(pointer)——C-C++的精髓
06-06
指针(pointer)——C-C++的精髓
C++基础入门------6.指针
T_T_T_T_的博客
11-12 214
指针 指针的基本概念 指针的作用：可以通过指针间接访问内存 ●内存编号是从0开始记录的，一般用十六进制数字表示 ●可以利用指针变量保存地址 指针变量的定义和使用 指针变量定义语法：数据类型 * 变量名； int main() { //1、定义指针 int a = 0;//定义整型变量a //指针变量定义语法：数据类型 * 指针变量名； int * p; //让指针记录变量a的地址 p = &a; cout << "a的地址为：" << &a
C++之指针（简单易懂，非常详细）
weixin_45984283的博客
04-15 6991
C++之指针（详细，简单易懂）
C++基础知识：教你彻底了解指针
weixin_49503250的博客
01-28 220
阿宋认为指针就是一种复合类型的变量。它由两部分组成，一部分是指针的本体，一部分是指针指向的对象。我们可以通过指针去改变指针指向对象的值，也可以更改指针所指向的对象。拿一般的单一类型的变量类型举例，char类型变量的内存中存放的是char类型的数据。int类型变量的内存中存放的是int类型的数据。而对于指针来讲，指针类型的变量内存中存放的是一个地址，而这个地址指向的才是存有对应数据类型的数据。要养成的一个习惯便是，看到一个指针，第一反应就是这个指针的值是一个地址。
C/C++指针相关知识点总结（学不完，根本学不完！！！！）
最新发布
qq_42595610的博客
06-21 498
指针是一个值为内存地址的变量（或数据对象）。首先指针是一个变量，它的值就是某个变量的内存地址，就好比 int 类型的变量它的值是整数也是一样的。//定义两个指针变量指向room int * p1 = & room;printf("room 地址：0x%p\n" , & room);printf("p1 地址：0x%p\n" , & p1);printf("p2 地址：0x%p\n" , & p2);printf("room 所占字节：%d\n" , izeof(room));
【c++】基础之指针
m0_64040304的博客
10-24 591
指针
C++指针——数组指针/函数指针
08-09
NULL 博文链接：https://448230305.iteye.com/blog/2191121
C++知识点——整合
01-27
引用是别名，声明时必须初始化。实际代码中多用作函数的形参，通过将引用变量用作参数，函数将使用原始数据，而不是其副本。price_count函数的两个形参都是const引用，可以接受const和非...指针是变量，可以重新
奇妙的C++——智能指针
03-18
NULL 博文链接：https://wuliangxx.iteye.com/blog/615291
c++ 指针详解
m0_62870588的博客
03-29 4万+
使用指针遍历数组 ；指针的概念与理解； 指针的含义；指针的创建与初始化 ；指针的基本操作；指针的解引用和取地址；指针的算数操作 ；指针相减 ；const指针；指向const的指针；指针的数组和数组的指针；数组的指针地址；指针的指针；const_cast ;reinterpret_cast;
C++ 的分级 （0 -- 10 ）
x_xx_xxx_xxxx的博客
10-20 3866
Life is too short to program in C++.                                                  --题记  每每在招聘网站上看到要求 -- “精通 C++ ，精通***，......”,我都不禁肝颤，因为真的不敢说精通，连熟悉都不敢说。可能是每个人划分的级别不同吧，尤其是企业，经常是：“工作经验一至三年，精通C
C/C++指针详解之基础篇（史上最全最易懂指针学习指南！！！！）
热门推荐
尘海折柳的博客
02-20 16万+
目录 一.变量的内存实质到 1.1变量的实质 1.2 赋值给变量 1.3变量在哪里？ 二. 指针是个什么东西？ 三. 二级指针（指针的指针） 3.1 定义与初始化 3.2间接数据访问 3.2.1.改变一级指针指向 3.2.2改变 N-1 级指针的指向 3.2.3二级指针的步长 四. 指针与数组 4.1 指针与数组名 4.1.1 通过数组名访问数组元素 4....
C++指针的基础知识
sinat_38679789的博客
01-05 179
在明白什么是指针之前，我们先看两个符号 ‘&amp;’取地址符号 ‘*’取值符号 具体含义就是 假设i是一个普通变量且i=9；，存储在10010这个地址内 那么“&amp;i”的值，就等于10010 假设p=10010（首先声明只是假设，指针不允许直接赋值） “*p”的值，就等于i的值，也就是9； 结合例子具体分析一下： 比如： int i = 6; printf("%d\n...
（C++）指针基础知识
Lemon_CHA的博客
07-25 199
指针 指针的作用：可以通过指针间接访问内存。
C++指针专题（基础扫盲）
伊一易水寒的博客
07-11 7520
指针的学习是每个C/C++初学者都无可避免的，最近在学习C++的同时，顺便复习了一下以前学的C的指针，有些地方本来不是很明白的现在也豁然开朗了(⊙o⊙) 什么是指针 让我们看看维基百科上的定义：计算机中的内存都是编址的，每个地址都有一个符号，就像家庭地址或者IP地址一样。指针，是一个无符号整数（unsigned int），它是一个以当前系统寻址范围为取值范围的整数。声明指针和声明一个无符号整数实质...
c++程序入门（一）——指针
zhangying_496的博客
10-18 369
1、指针定义：存放变量地址的变量。int *pi; 2、* 和 &： *：指针运算符是间接引用操作符，产生指针所指向的数据； &：取地址操作符（和*一起使用时，因为在另外的情况下，&也可以用作引用） 3、常量指针和指针常量 常量指针：const int* pi1; //所指向的对象只能被读取，不能被改写！ 指针常量：int * const pi2; //不能修改指针 4
浅谈指针的特点
01-01 1557
这是一篇我所见过的关于指针的最好的入门级文章，它可使初学者在很短的时间内掌握复杂的指针操作。虽然，现在的JAVA、C＃等语言已经取消了指针，但作为一个C++程序员，指针的直接操作内存，在数据操作方面有着速度快，节约内存等优点，仍是很多C++程序员的最爱。指针就像是一把良剑，就看你怎么去应用它!什么是指针？　　其实指针就像是其它变量一样，所不同的是一般的变量包含的是实际的真实的数据，而指针是一个指示
C++中指针的基础知识
愚 公
04-17 504
》指    针      即指针变量，与其他类型变量一样，指针变量也必须要先声明。一般形式：                          *；      其中，是指针所指对象的类型，在C++中指针可以指向任何C++类型。是指针变量名。      指针使用两种特殊的运算符 *和&。      一元（单目）运算符&用于返回其操作对象的内存地址，其操作对象通常为一个变量名。
指针和C++的基本原理
24_hour的专栏
09-09 985
C++这种面向对象的编程和类似Java只面向过程的区别：面向对象强调的是在运行阶段即运行阶段。好像C++是真人秀，什么样的表现取决于当天录节目是出现的各种情况。而面向过程呢，就像是话剧演员，是按照剧本一板一眼，剧情都是审定好的了。我们都知道，调试程序时候，分为编译阶段和运行阶段。例如数组，在C++中我们必须指定数组的长度。设定好了，这就是属于编译阶段决策。这样的方法我们就会出现浪费内存的状况。因为
关联分析——FP-growth算法 C++带类优化实现及案例
05-23
本文将介绍如何使用C++实现FP-growth算法，并通过一个具体的案例来说明算法的应用。 一、FP-growth算法原理 FP-growth算法的主要思想是基于频繁项集的增长，通过构建FP树来高效地挖掘频繁项集。其基本流程如下： ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值