这次主要学习的是指针
一、指针
作用：可以通过指针间接访问内存
1、内存编号是从0开始记录的，一般从十六进制数字表示
2、可以利用指针变量保存地址
#include<iostream>
using namespace std;
int main()
{
//1、定义指针
int a = 10;
int* p = &a;
cout << "a的地址为：" << &a << endl;
cout << "指针p为：" << p << endl;
//2、使用指针
//可以通过解引用的方式来找到指针指向的内存
//指针前加*代表解引用，找到指针指向的内存数据，后可以对其进行修改或读取
*p = 100;
cout << "a= " << a << endl;
cout << "*p= " << *p << endl;
//3、指针所占的内存空间
cout << *p << endl;
cout << sizeof(p) << endl;
cout << sizeof(char*) << endl;
cout << sizeof(float*) << endl;
cout << sizeof(double*) << endl;
system("pause");
return 0;
}二、空指针
指针变量指向内存中编号为0的空间
用途：初始化指针变量
注意：空指针指向的内存是不可以访问的
#include<iostream>
using namespace std;
int main()
{
//1、空指针用于给指针变量进行初始化
int* p = NULL;
//2、空指针是不可以进行访问的
//0~250之间的内存编号是系统占用的，因此不可以访问
cout << *p << endl;
system("pause");
return 0;
}三、野指针
指针变量指向非法的内存空间
为申请操控不可访问，在程序中尽量避免出现野指针
四、const修饰指针
三种情况
1.const修饰指针——常量指针
2.const修饰常量——指针常量
3.const既修饰指针又修饰变量
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int b = 10;
//const修饰的是指针，指针指向可以改，指针指向的值不可更改
const int* p1 = &a;
p1 = &b;//正确
//*p1 = 100;报错
//const修饰的是常量，指针指向不可更改，指针指向的值可以更改
int* const p2 = &a;
//p2 = &b;报错
*p2 = 100;//正确
//const既修饰指针又修饰变量
const int* const p3 = &a;
//p3 = &b;
//*p3 = 100;
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;
cout << "利用指针遍历数组" << endl;
int* p2 = arr;
for (int i = 0; i < 10; i++)
{
cout << *p2 << endl;
p2++;
}
return 0;
}六、指针和函数
作用：利用指针作函数参数，可以修改实参的值
地址传递是传递指针指向地址中的值，而不是交换参数的地址
#include<iostream>
using namespace std;
//值传递
void swap1(int a, int b)
{
int temp = a;
a = b;
b = temp;
}
//地址传递
void swap2(int* p1, int* p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
int main()
{
int a = 10;
int b = 20;
swap1(a,b);//值传递不会改变实参
swap2(&a, &b);//地址传递会改变实参
cout << "a=" << a << endl;
cout << "b=" << b << endl;
return 0;
}七、指针、数组、函数的结合
案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序
例如数组：int arr[10] = {4,3,6,9,1,2,10,8,7,5}
#include<iostream>
using namespace std;
//冒泡排序
void bubbleSort(int* arr, int len)//int *arr也可写成int arr[]
{
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len - 1 - i; 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[i] << endl;
}
}
int main()
{
//1、先创建数组
int arr[10] = { 4,3,6,9,1,2,10,8,7,6 };
int len = sizeof(arr) / sizeof(arr[0]);//数组长度
//2、创建排序，实现冒泡排序
bubbleSort(arr, len);///数组名就是数组的首地址
//3、打印排序后的数组
printArray(arr, len);
return 0;
}八、指针运算
1、两个重要的运算符：
&取地址符，该运算可取得一个变量的地址
*取内容符，该运算可取得某个地址中所存放的数据
2、算数运算：
++、--、+、-（其他的运算没有意义）
char *pc = NULL;
printf("%p%p\n",pc,pc+1);//0 1
int *pi = NULL;
printf("%p%p\n",pi,pi+1);//0 4
double *pd = NULL;
print("%p%p\n",pd,pd+1);//0 8总结：
1、指针的每一次递增，它其实会指向下一个元素的存储单元
2、指针的每一次递减，它都会指向前一个元素的存储单元
3、指针在递增和递减跳跃的字节数取决于指针所指向变量数据类型的长度
4、不同类型的指针所占内存大小都是一样的（32位计算机4个字节，64位8个字节）
九、一些代码小案例
给定一个数组，求出数组中最小的偶数
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i)
{
cin >> a[i];
}
int smallestEven = numeric_limits<int>::max(); // 初始化为最大整数值以便于比较
for (int num : a) {
if (num % 2 == 0 && num < smallestEven) {
smallestEven = num;
}
}
cout << smallestEven << endl;
return 0;
}534, 386, 319, 692, 169, 338, 521, 713, 640, 692, 969, 362, 311, 349, 308, 357, 515, 140, 591, 216，
57, 252, 575, 630, 95, 274, 328, 614, 18, 605, 17, 980, 166, 112, 997, 37, 584, 64, 442, 495,
821, 459, 453, 597, 187, 734, 827, 950, 679, 78, 769, 661, 452, 983, 356, 217, 394, 342, 697, 878,
475, 250, 468, 33, 966, 742, 436, 343, 255, 944, 588, 734, 540, 508, 779, 881, 153, 928, 764, 703,
459, 840, 949, 500, 648, 163, 547, 780, 749, 132, 546, 199, 701, 448, 265, 263, 87, 45, 828, 634
小蓝想从中选出一部分数求和，使得和是24的倍数，请问这个和最大是多少？
#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;
int max(const vector<int>& nums, int k)
{
int n = nums.size();
vector<vector<int>> arr(n + 1, vector<int>(k, INT_MIN));
arr[0][0] = 0;
for (int i = 1; i <= n; ++i) {
int num = nums[i - 1];
int modNum = num % k;
for (int j = 0; j < k; ++j) {
// 不选当前数字
arr[i][j] = arr[i - 1][j];
// 选当前数字
if (arr[i - 1][(j - modNum + k) % k] != INT_MIN) {
arr[i][j] = max(arr[i][j], arr[i - 1][(j - modNum + k) % k] + num);
}
}
}
return arr[n][0];
}
int main() {
vector<int> nums = {
534, 386, 319, 692, 169, 338, 521, 713, 640, 692, 969, 362, 311, 349, 308, 357, 515, 140, 591, 216,
57, 252, 575, 630, 95, 274, 328, 614, 18, 605, 17, 980, 166, 112, 997, 37, 584, 64, 442, 495,
821, 459, 453, 597, 187, 734, 827, 950, 679, 78, 769, 661, 452, 983, 356, 217, 394, 342, 697, 878,
475, 250, 468, 33, 966, 742, 436, 343, 255, 944, 588, 734, 540, 508, 779, 881, 153, 928, 764, 703,
459, 840, 949, 500, 648, 163, 547, 780, 749, 132, 546, 199, 701, 448, 265, 263, 87, 45, 828, 634
};
int k = 24;
int result = max(nums, k);
cout << "最大的和为24的倍数的子集和为: " << result << endl;
return 0;
}北京奥运会要到了，小青拼命练习游泳准备参加游泳比赛，小青希望能够被选上参加奥运会。
每天，小青给自己的游泳时间做了精确的计时，计时都按 24小时制计算），小青从 a 时 b 分一直游泳到当天的 c 时d 分，请你帮小青计算一下，它这天一共游了多少时间呢？
输入格式
按a:b c:d 格式输入四个整数，分别表示开始训练的时间a 时 b 分和结束训练的时间c 时d 分。
输出格式
按 h时m分 格式输出训练的时间，表示小青这天一共游了多少小时多少分钟。其中表示分钟的整数 m 应该小于60。
#include<iostream>
#include<iomanip>
using namespace std;
int main()
{
int a,b,c,d;
char colon;
cin >> a >> colon >> b;
cin >> c >> colon >> d;
int startminutes = a*60+b;
int endminutes = c*60+d;
int taketotalminutes = endminutes-startminutes;
int h = taketotalminutes/60;
int m = taketotalminutes%60;
cout << h <<"时"<< m << "分" << endl;
return 0;
}
#include<iostream>
using namespace std;
int a[110];
int main()
{
int n;
cin >> n;
for (int i = 1; i <= n; i++)
{
cin >> a[i];
}
int t;
cin >> t;
int luck = 0;
for (int i = 1; i <= n; i++)
{
if (a[i] == t)
{
luck += 10;
}
else
{
luck -= abs(a[i] - t);
}
}
if (luck > 0)
{
cout << luck << endl;
cout << "Happy" << endl;
}
else
{
cout << luck << endl;
}
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
