2021-02-03

最新推荐文章于 2021-06-16 16:17:46 发布
最新推荐文章于 2021-06-16 16:17:46 发布
阅读量110 收藏
点赞数
分类专栏： C++学习 文章标签： 指针 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZAJ1996/article/details/113589097
版权

指针

通过指针来保存一个地址，地址里有数据

/*指针*/
#include <iostream>
using namespace std;

int main()
{
	//定义指针
	int a = 10;
	//指针定义的语法：数据类型*指针变量
	int * p;
	//让指针p记录a的地址
	p = &a;
	cout << "a的地址为：" << &a << endl;
	cout << "指针p为：" << p << endl;
	//使用指针
	//可以通过解引用的方式来找到指针指向的内存
	//指针前加*代表解引用，找到指针指向的内存中的数
	*p = 1000;
	cout << "a=" << a << endl;//1000
	cout << "*p=" << *p << endl;//1000
	system("pause");
	return 0;
}

指针所占内存空间

在32位操作系统下，占用4个字节空间
在64位操作系统下，占用8个字节空间

/*指针所占内存空间*/
#include <iostream>
using namespace std;

int main()
{
	int a = 10;
	int * p = &a;
	//在32位操作系统下，不管什么类型的指针都占4个字节空间
	//在64位操作系统下，不管什么类型的指针都占8个字节空间
	cout << "sizeof(int *)=" << sizeof(int *) << endl;
	cout << "sizeof(float *)=" << sizeof(float *) << endl;
	cout << "sizeof(double *)=" << sizeof(double *) << endl;
	cout << "sizeof(char *)=" << sizeof(char *) << endl;
	system("pause");
	return 0;
}

空指针和野指针

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

/*空指针*/
#include <iostream>
using namespace std;

int main()
{
	//对指针变量进行初始化
	int *p = NULL;
	//空指针不可以进行访问
	//0~255的内存编号是系统占用的，因此不可以访问
	//*p=100；
	system("pause");
	return 0;
}

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

/*野指针*/
#include <iostream>
using namespace std;

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

const修饰指针

const修饰指针：常量指针
指针的指向可以修改，但指针指向的值不可以修改

const修饰常量：指针常量
指针的指向不可以修改，但指针指向的值可以修改

const既修饰指针，又修饰常量
指针的指向和指向的值都不可以修改

/*const修饰指针*/
#include <iostream>
using namespace std;

int main()
{
	//const修饰指针：常量指针
	int a = 10;
	int b = 10;
	const int * p = &a;
	p = &b;
	//* p = 20;错误
	//指针指向的值不可以改，指针的指向可以改

	//const修饰常量：指针常量
	int * const p2 = &a;
	*p2 = 20;
	//p2 = &b;错误

	//const既修饰指针，又修饰常量
	const int * const p3 = &a;
	//p3 = &b;错误
	//*p3 = 20;错误
	
	system("pause");
	return 0;
}

指针和数组

/*指针和数组*/
#include <iostream>
using namespace std;

int main()
{
	//利用指针访问数组中的元素
	int arr[10] = {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;
	//利用指针遍历数组
	int * p2 = arr;
	for (int i = 0; i < 10; i++)
	{
		//cout << arr[i] << endl;
		cout << *p2 << endl;
		p2++;
	}
	system("pause");
	return 0;
}

指针和函数

利用指针做函数参数，可以修改实参的值

/*指针和函数*/
#include <iostream>
using namespace std;

//实现数字交换
void swap01(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;
}
void swap02(int * p, int * p2)
{
	int temp = *p;
	*p = *p2;
	*p2 = temp;
}
int main()
{
	//值传递
	int a = 10;
	int b = 20;
	swap01(a, b);
	//地址传递
	//如果是地址传递，可以修饰实参
	swap02(&a, &b);
	cout << "a=" << a << endl;//20
	cout << "b=" << b << endl;//10
	system("pause");
	return 0;
}

指针、数组、函数

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

/*指针、数组、函数*/
#include <iostream>
using namespace std;

//冒泡排序函数 参数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++)
		{
			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)
{
	for (int i = 0; i < len; i++)
	{
		//cout << *arr << " ";
		//arr++;也可以这样写
		cout << arr[i] << " ";
	}
	cout << endl;
}
int main()
{
	//创建数组
	int arr[10] = { 5,3,4,7,2,1,8,5,10,9 };
	int len = sizeof(arr) / sizeof(arr[0]);
	//创建函数实现冒泡排序
	bubbleSort(arr, len);
	//展示结果
	printArray(arr, len);
	system("pause");
	return 0;
}

结构体

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型

/*结构体*/
#include <iostream>
#include <string>
using namespace std;

//1、创建学生数据类型 学生（姓名，年龄，分数）
struct Student
{
	//成员列表
	//姓名
	string name;
	//年龄
	int age;
	//分数
	int score;
}s3;//顺便创建结构体变量


int main()
{
	//2、通过学生类型创建具体学生
	//2.1 struct Student s1
	struct Student s1;//struct关键字可以省略
	//给s1属性赋值，通过.访问结构体变量中的属性
	s1.name = "张三";
	s1.age = 18;
	s1.score = 100;
	cout << "姓名：" << s1.name << "年龄：" << s1.age << "分数：" << s1.score << endl;
	//2.2 struct Student s2 = {...};
	struct Student s2 = { "李四",19,90 };
	cout << "姓名：" << s2.name << "年龄：" << s2.age << "分数：" << s2.score << endl;
	//在定义结构体时顺便创建结构体变量
	s3.name = "王五";
	s3.age = 20;
	s3.score = 80;
	cout << "姓名：" << s3.name << "年龄：" << s3.age << "分数：" << s3.score << endl;
	system("pause");
	return 0;
}

结构体数组

将自定义的结构体放入到数组中方便维护

/*结构体数组*/
#include <iostream>
#include <string>
using namespace std;

//1、创建学生数据类型 学生（姓名，年龄，分数）
struct Student
{
	//成员列表
	//姓名
	string name;
	//年龄
	int age;
	//分数
	int score;
};


int main()
{
	//2、创建结构体数组
	struct Student stuArr[3]=
	{
		{"张三",18,100},
		{"李四",19,90},
		{"王五",20,80}
	};
	
	//3、给结构体数组中的元素赋值
	stuArr[2].name = "赵六";
	stuArr[2].age = 80;
	stuArr[2].score = 60;
	//4、遍历结构体数组
	for (int i = 0; i < 3; i++)
	{
		cout << "姓名：" << stuArr[i].name << endl;
		cout << "年龄：" << stuArr[i].age << endl;
		cout << "分数：" << stuArr[i].score << endl;
	}
	system("pause");
	return 0;
}

结构体指针

通过指针访问结构体中的成员
利用操作符->可以通过结构体指针访问结构体属性

/*结构体指针*/
#include <iostream>
#include <string>
using namespace std;

//1、创建学生数据类型 学生（姓名，年龄，分数）
struct Student
{
	//成员列表
	//姓名
	string name;
	//年龄
	int age;
	//分数
	int score;
};


int main()
{
	//2、创建结构体变量
	struct Student s = { "张三",18,100 };
	
	//3、通过指针指向结构体变量
	struct Student * p = &s;
	//4、通过指针访问结构体变量中的数据
	cout << "姓名：" << p->name << endl;
	cout << "年龄：" << p->age << endl;
	cout << "分数：" << p->score << endl;
	
	system("pause");
	return 0;
}

结构体嵌套结构体

/*结构体嵌套结构体*/
#include <iostream>
#include <string>
using namespace std;

//1、创建学生数据类型 学生（姓名，年龄，分数）
struct Student
{
	//成员列表
	//姓名
	string name;
	//年龄
	int age;
	//分数
	int score;
};

//创建老师结构体
struct Teacher
{
	int id;
	string name;
	int age;
	struct Student stu;
};

int main()
{
	//2、创建结构体变量
	Teacher t = { 1,"老王",50,{"张三",18,100} };
	
	cout << "老师姓名：" << t.name << endl;
	cout << "辅导的学生：" << t.stu.name << endl;
	
	system("pause");
	return 0;
}

结构体做函数参数

将结构体作为参数向函数传递
两种传递方式：
值传递
地址传递

/*结构体做函数参数*/
#include <iostream>
#include <string>
using namespace std;

struct Student
{
	string name;
	int age;
	int score;
};
//值传递
 void printStudent1(struct Student s)
 {
	 s.age = 200;
	 cout << "子函数中 姓名：" << s.name << "年龄：" << s.age << "分数：" << s.score << endl;
 }
 //地址传递
 void printStudent2(struct Student * p)
 {
	 p->age = 200;
	 cout << "子函数2中 姓名：" << p->name << "年龄：" << p->age << "分数：" << p->score << endl;
 }
int main()
{
	//将学生传递到一个参数中，打印学生身上的所有信息
	Student stu = { "张三",18,100 };
	
	/*cout << "main函数中打印 姓名：" << stu.name << endl;
	cout << "main函数中打印 年龄：" << stu.age << endl;
	cout << "main函数中打印 分数：" << stu.score << endl;*/
	printStudent1(stu);
	cout << "main函数中打印 姓名：" << stu.name << endl;
	cout << "main函数中打印 年龄：" << stu.age << endl;//18
	cout << "main函数中打印 分数：" << stu.score << endl;
	printStudent2(&stu);
	cout << "main函数中打印 姓名：" << stu.name << endl;
	cout << "main函数中打印 年龄：" << stu.age << endl;//200
	cout << "main函数中打印 分数：" << stu.score << endl;
	system("pause");
	return 0;
}

结构体中const使用场景

用const来防止误操作

/*结构体中const使用场景*/
#include <iostream>
#include <string>
using namespace std;

struct Student
{
	string name;
	int age;
	int score;
};
//值传递
 void printStudent(struct Student s)
 {
	 cout << "子函数中 姓名：" << s.name << "年龄：" << s.age << "分数：" << s.score << endl;
 }
 //地址传递 可以减少内存，而且不会复制一个新的副本出来
 void printStudent2(const struct Student * p)//加const防止误操作 
 {
	 cout << "子函数2中 姓名：" << p->name << "年龄：" << p->age << "分数：" << p->score << endl;
 }
int main()
{
	Student stu = { "张三",18,100 };
	
	printStudent2(&stu);

	system("pause");
	return 0;
}

结构体案例

案例1：学校正在做毕设项目，每名老师有5个学生，共有3个老师。设计学生和老师的结构体，其中老师的结构体中包含老师的名字和一个存放5名学生的数组，学生的成员有姓名、分数，创建数组存放3名老师，通过函数给每名老师及所带的学生赋值，最后打印出每名老师和所带学生的数据

/*结构体案例1*/
#include <iostream>
#include <string>
#include <ctime>
using namespace std;

struct Student
{
	string sName;
	int score;
};
struct Teacher
{
	string tName;
	Student stu[5];
};
//给老师和学生赋值的函数
void allocateSpace(Teacher tArray[],int len)
{
	string nameSeed = "ABCDE";
	//给老师开始赋值
	for (int i = 0; i < len; i++)
	{
		tArray[i].tName = "Teacher_";
		tArray[i].tName += nameSeed[i];
		//通过循环给老师所带的5个学生赋值
		for (int j = 0; j < 5; j++)
		{
			tArray[i].stu[j].sName = "Student_";
			tArray[i].stu[j].sName += nameSeed[j];
			int random = rand() % 61 + 40;//40~100
			tArray[i].stu[j].score = random;
		}
	}
}
void printInfo(Teacher tArray[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << "老师的姓名：" << tArray[i].tName << endl;
		for (int j = 0; j < 5; j++)
		{
			cout << "\t学生姓名：" << tArray[i].stu[j].sName <<" 分数："<<tArray[i].stu[j].score<< endl;

		}
	}
}
int main()
{
	//随机数种子
	srand((unsigned int)time(NULL));
	//1、创建3名老师的数组
	Teacher tArray[3];
	//2、通过函数给3名老师的信息赋值，并对其所带学生的信息进行赋值
	int len = sizeof(tArray) / sizeof(tArray[0]);
	allocateSpace(tArray, len);
	//3、打印所有老师及所带学生的信息
	printInfo(tArray, len);

	system("pause");
	return 0;
}

案例2：设计一个英雄的结构体，包含姓名、年龄、性别。创建一个结构体数组，里面包含5名英雄，根据冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，并将结果打印输出。

/*结构体案例2*/
#include <iostream>
#include <string>
#include <ctime>
using namespace std;

//1、设计英雄结构体
struct Hero
{
	string name;
	int age;
	string gender;
};
void bubbleSort(Hero heroArray[], int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - i - 1; j++)
		{
			if (heroArray[j].age > heroArray[j + 1].age)
			{
				Hero temp = heroArray[j];
				heroArray[j] = heroArray[j+1];
				heroArray[j+1] = temp;
			}
		}
	}
}
void printHero(Hero heroArray[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << "姓名：" << heroArray[i].name << "年龄：" << heroArray[i].age << "性别：" << heroArray[i].gender << endl;
	}
}
int main()
{
	//2、创建数组存放5名英雄
	Hero heroArray[5] = {
		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"}
	};
	int len = sizeof(heroArray) / sizeof(heroArray[0]);
	//冒泡排序
	bubbleSort(heroArray, len);
	//排序后打印输出
	printHero(heroArray, len);
	system("pause");
	return 0;
}
ZAJ1996
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++实现封装一个函数，利用冒泡排序，实现对整型数组的升序排序。
LImitation_wxg的博客
03-17 2603
完整代码： #include<iostream> using namespace std; //定义一个冒泡排序升序函数；实现一维数组的升序排序； //函数定义： void maopao(int * p, int len)//也可写成int p[ ]；引入数组的首地址p=arr； { cout << "冒泡升序前的数组为：" << endl; for (i...
#1：C++：初步知识；
张小凯的个人空间
01-20 852
C++ 的初步认识： 1. 在 C++ 中 一般在主函数 main 前面用 int来定义，表示返回值为整形，     如果程序正常执行，这返回值为 0； 否则返回值为非零，一般为-1；   2. 在 C++ 中，一般使用 cout ， cin 表示输出和输入；     对于 cout 表示 c 和 out 的组合，表示输出流对象，          本例中的作用是把
一维数组的函数冒泡排序法--C语言
weixin_45661800的博客
02-14 1937
一维数组的函数冒泡排序法 #include "stdafx.h" void max(int a[] ) { int i,j,max,pos,temp; for (i=0;i<=8;i++) { for(j=0,max=-100;j<=9-i;j++) { if(a[j]>max) { max=a[j]; pos=j; }...
c语言 自定义类型数组排序,C语言将冒泡排序(或选择排序)改造成函数，实现对一个一维数组中的元素进行排序...
weixin_42360972的博客
05-18 1547
满意答案/*其实就是把排序封装成一个函数即可，使用时传递数组的引用便可以实现对数组元素进行排序了，因为数组传递的就是地址*/#includevoid sort(int a[],int n){int i,j,temp;for(i=0;ifor(j=i;jif(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}}}void main(){int n;//数组元...
用冒泡法实现数组内20个整数从小到大排列
J丶k
12-05 4466
#include using namespace std; int main() {  int a[20],i,j,k;  cout  for(i=0;i   cin>>a[i];  cout  for(j=0;j   for(i=0;i    if(a[i]>a[i+1])    {     k=a[i];     a[i]=a[i+1];     a[i+1]=k
2021-02-03-sd-export-bundle：标准演示导出捆绑
02-24
在IT行业中，"2021-02-03-sd-export-bundle"看起来像是一个特定项目或软件开发过程中的版本标识，日期格式（2021-02-03）表明这是2021年2月3日创建或更新的。"标准演示导出捆绑"可能是该项目或软件的一个功能模块，...
2021-03-02-shiny
02-12
木工车间模板 该存储库是The Carpentries的（ ， 和的）模板，用于创建研讨会的网站。 请不要直接在GitHub上存储此存储库。 相反，请按照以下使用GitHub的“模板”功能复制此workshop-template存储库并为您的工作坊...
2021-03-02-ams
02-09
木工车间模板 该存储库是The Carpentries的（ ， 和的）模板，用于创建研讨会的网站。 请不要直接在GitHub上存储此存储库。 相反，请按照以下使用GitHub的“模板”功能复制此workshop-template存储库并为您的工作坊...
-02-03-2021-
03-09
...DOCTYPE>声明、元素、元素和元素组成。<!...元素是整个文档的根元素；包含元数据，如标题、字符集设置等；则包含实际可见的网页内容。...每个标签都有特定的功能，比如标签用于创建超链接，用于插入图像。...
nodemcu-release-18-modules-2021-06-04-02-03-43-integer.bin
06-04
You successfully commissioned a NodeMCU custom build from the release branch.... We'll keep you posted by email about the progress of your build. In the meantime I suggest you take a look at the build ...
Ultimate 2021-03-02 16-12-43.zip
03-02
标题中的"Ultimate 2021-03-02 16-12-43.zip"可能指的是一个包含一系列文件的压缩包，创建日期为2021年3月2日的16时12分43秒。这个时间戳表明这是某个项目或工作的一个特定版本或快照，可能是为了备份、分享或记录...
Arduino-RGB-LED:2021-03-09-RGB-LED
03-09
标题中的"Arduino-RGB-LED:2021-03-09-RGB-LED"揭示了这个项目是关于使用Arduino控制RGB-LED的，日期可能是项目创建或更新的时间。描述部分进一步证实了这一点，指出这是一个名为"Joystick_RGB_LED"的项目，通过操纵...
UMPToolV7200(2020-02-21) CBM209X UMPToolV7200(2020-03-19)
01-21
"UMPToolV7200(2020-02-21) CBM209X UMPToolV7200(2020-03-19)" 这个标题指的是芯邦科技（Chipbond Technology）推出的固件更新或量产工具的两个不同版本。UMPTool，全称为Universal Memory Programming Tool，是一...
Tekton-Second-Github2021-03-12T01-02-37.848Z:为工具链创建
03-12
这个名为 "Tekton-Second-Github2021-03-12T01-02-37.848Z" 的压缩包文件似乎包含了一个 Tekton 管道的示例，用于展示如何利用 Tekton 构建工具链。 Tekton 管道是 Tekton 的核心组件，它允许开发者定义一系列的...
2021-2022收藏的精品资料2021-2022年出纳实习计划范文3篇.doc
09-16
- 见习时间通常设定为一个月，如xx年02月20日至03月20日。 - 实习方式为个人自行联系实习单位，可能包括国家企事业单位的出纳、财务等相关岗位。 3. **实习内容**： - **了解企业情况**：包括企业名称、位置、...
C语言《一维数组的学习，冒泡排序》
weixin_30339457的博客
06-03 412
#include<stdio.h> /* 一维数组的学习，冒泡排序 soulsjie 20170623 */ void main(){ int a[6]; int i,j,k; printf("请输入6数：\n"); for(i=0;i<=5;i++) scanf("%d",&a[i]); printf("\n"); //冒泡排...
一维数组，对数组元素做冒泡排序
qq_43071318的博客
10-31 1146
// BubbleSort.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 //利用冒泡排序对数组中元素排序 #include <stdio.h> void main() { int a[10]; printf("Please input 10 numbers:\n"); for (int i = 0; i < 10; i++) { sca...
一维数组的冒泡排序
qq_41891425的博客
06-08 951
代码模块化 1.在maopao.h文件中定义排序函数 int *sequence(int *a[])和输出函数 void display(int *a) 排序函数的参数是数组 ，是将要排序的一维数组传入；其返回值是返回指针，因为要将排好序的数组返回。但是由于c语言中数组是不能作为返回值的，只能用指针来代替。 输出函数的参数是一个指针（也可以换成数组），传入要输出的数组的首地址 2.在maopao.c中将排序函数和冒泡函数实现 冒泡排序的原理 以上面的一维数组为例，8个元素，比较7次 第一次：第一个
C语言之一维数组之冒泡降序排序
lengnu1913的博客
06-16 7595
设计一子函数用冒泡排序法对8个元素的一维整型数组降序排序。一维数组元素从键盘输入。 要求： 1、使用子函数： void Sort(int a[],int n)//n是数组元素个数。 2、在子函数中实现排序，不允许在子函数中输出。 【输入形式】 主函数中循环输入一个8个数组元素。 【输出形式】 输出排序后的数组 【样例输入】 1 2 6 67 7 4 5 【样例输出】 7 7 6 6 5 4 2 1 【样例说明】 数组元素是键盘输入。输出排序后元素。 【评分标准】 ...
java 集合 2023-01,2023-02,2023-03,2023-04 2023-05,2023-06, 2022-01,2022-02,2022-03,2022-04,2022-05,2022-06，2021-01,2021-02,2021-03,2021-04,2021-05,2021-06 这样的数据变成 2023-01,2022-01,2021-01,2023-02,2022-02,2021-02
最新发布
06-09
dates.add("2021-02"); dates.add("2021-03"); dates.add("2021-04"); dates.add("2021-05"); dates.add("2021-06"); // 对日期进行排序 Collections.sort(dates); // 遍历并提取年份和月份，组合成新的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值