一.内存和地址
1内存
内存就是一片空间,用来存放东西的地方,那么对与计算机来讲,肯定是存放各种数据和程序的地方。计算机上CPU(中央处器)在处理数据的时候,需要的数据是通过数据总线在内存中读取的,处理后的数据也会通过数据总线放回内存中,但是CPU是怎么知道要进行数据的存入和读出,并且准确无误地找到数据要存放和读出的地方,这里就要引出地址的概念了。
2地址
内存是一片很大的空间,把内存划分为⼀个个的内存单元,每个内存单元的大小取1个字节,这样可以更好地管理数据。然后给每一个内存单元都分配一个编号,可以通过这个编号找到对应的内存单元,也就是地址。而C语言中,我们可以这样理解,内存单元的编号 = 地址= 指针
计算机中常⻅的单位(补充):
⼀个⽐特位可以存储⼀个2进制的位1或者0
1Byte = 8bit(比特位)
1KB = 1024Byte(字节)
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB
二.指针
1.操作符(&)-取地址操作符
#include <stdio.h>
int main()
{
int p=2;
printf("%p",&p);
return 0;
}
&a取出的是a所占4个字节中地址较小的字节的地址。
比如,虽然整型变量占用4个字节,我们只要知道了第⼀个字节地址,计算机系统顺藤摸瓜便可访问到4个字节的数据也是可行的。
(32位机器的寻址空间是2^32, 即32个bit,也就是4个字节。同理64位编译器-寻址空间为八个字节。)
1、1个字节(Byte) 为8位二进制
2、Int类型 占用4个字节
3、long类型 占用8个字节
4、float类型占用4个字节
5、double类型占用8个字节
2.解引用符(*)
我们放了一个东西在一个内存空间内,那我们现在就可以通过地址去访问。
此时就用到了,解引用符(*)。
int m=2;
int* p = &m; 调用时函数传参传&num
"%d", *p; *p相当于成为p的整型数值
"%p", p; p相当于&p为p的地址
下面我们看具体的代码实现
#include <stdio.h>
int main()
{
int p=2;
int *x=&p;
printf("%d\n",*x);
printf("%p\n",x);
return 0;
}
三.数组指针与指针数组
1数组指针:数组指针是指向数组的指针,存放的是数组的地址。(常用于二维数组的使用)
#include <stdio.h>
int main()
{
int arr[2][3] = { 1,2,3,4,5,6 };
int(*p)[3] = arr;
int i, j;
for (i = 0; i < 2; i++) {
for (j = 0; j < 3; j++) {
printf("%d\n", *(p[i] + j));//printf("%d\n",*(*(p+i)+j));
}
}
printf("\n");
return 0;
}
对于这个(*p)[3]这个(*p)是指针数组,[3]是其中的数组长度,(*p)[3]将数组类型转换为(*p)
对于*(*(p+i)+j))或者*(p[i]+j)
1. *(*(p+i))+j
这个表达式首先通过 p+i 计算出数组中的一个元素的地址,然后使用 (*) 解引用这个地址得到该位置的值,再对这个值进行解引用操作 (*) ,最后加上 j 。它实际上先访问了数组的一个元素,再对该元素进行操作。2. *(p[i]+j)
这个表达式直接计算p[i]+j,将数组下标 i 和 j 相加得到一个新的偏移量,然后用这个偏移量去数组 p 中查找元素并取值。这里没有两次解引用,一次解引用就完成了对指定位置元素的操作。
总结区别:
- 优先级不同:*(*(p+i)) 中两个 * 运算符的优先级高于 + ,所以会先解引用两次;而 *(p[i]+j) 的 + 先于 * 执行。
- 内部顺序不同:第一个表达式先解引用 p+i 指向的内存,再解引用那个值,第二个表达式则是直接访问 p 中 i 和 j 组合后的索引位置。
p是二维数组第一行的地址;
p+i是二维数组第i行的地址;
*(p+i)是二维数组第i行元素组成的一维数组的数组名,也是第i行这个一维数组的首元素地址;
*(p+i)+j就是第i行第j列元素的地址。
*p相当于第一行元素组成的数组的数组名arr[0],*(*(p+0)+0)只不过将0省略了,也是这个数组arr[0]首元素的地址,即arr[0][0]
的地址。
2指针数组:指针数组是存储指针的数组。(用于一维数组较为方便)
我们使用的是一个新的pa地址变量来取arr的首地址,但是arr本身就可以是首地址。
有如下表达形式:
#include <stdio.h>
int main()
{
int arr[10]={0,1,2,3,4,5,6,7,8,9};
int* pa=arr;
int i=0;
for(i=0;i<10;i++)
printf("%d %d %d \n",*(arr+i),*(pa+i),pa[i]);
}
3.简单应用
1.使用函数传参
#include <stdio.h>
void s(int* p);//函数原型
int main()
{
int p = 2;
printf("%p\n", &p);
s(&p);
return 0;
}
void s(int* p)//传入的应该是指针P----&p
{
printf("%p\n", p); //p==&p
printf("%d\n", *p); //*p的数据类型为int
}
2.使用指针输出数组并且求和
#include <stdio.h>
int main()
{
int* p;
int arr[] = { 1,2,3,4,5 };
p = arr;
int x = 0;
//for (p; p<arr + 5; p++)
//{
// printf_s("%d", *p);
//}
while (p < arr + 5)
{
x += *p;
printf("%d\n", *p);
p++;
}
printf("%d", x);
return 0;
}
3.将数组两个特定的数中间的数放前面去
#include <stdio.h>
void move(int arr[], int n, int m);
int main()
{
int arr[] = { 1,2,3,4,5 };
move(arr, 5, 2);
int q;
for (q = 0; q < 5; q++)
{
printf("%d", *(arr + q));
}
return 0;
}
void move(int arr[], int n, int m)
{
int a;
int t, i;
for (a = 0; a < m; a++)
{
t = *(arr + n - 2);
for (i = n - 1; i > 0; i--)//arr[1+n-2]=arr[1+n-3] arr[1+n-3]=arr[1+n-4] //arr[]={1,2,3,4,5,6} 6 2 //n为个数,m为后面多少个数
{
*(arr + i - 1) = *(arr + i - 2);
}
*arr = t;
}
}
4.求一个字符数组的长度
#include <stdio.h>
#include <string.h>
int en(char* c);
int main()
{
char c[] = { 'a','b','c','d','\0' };
int lenn = strlen(c);
printf("%d\n", en(c));//使用指针遍历
printf("%d\n", lenn);//使用strlen
return 0;
}
int en(char* c)
{
int len = 0;
while (*c != '\0')
{
len++;
*c++;
}
return len;
}
5.使用指针比大小
#include <stdio.h>
int en(int* p, int* q);
int main()
{
int p = 3;
int q = 4;
if (p != q)
{
printf("%d", en(&p, &q));
}
else
printf("一样大");
return 0;
}
int en(int* p, int* q)
{
if (*p > *q)
{
return *p;
}
else
return *q;
}
5.求数组中的最大值
#include <stdio.h>
int main()
{
int arr[] = { 2,3,4,5,43,55,7,45 }, * p, max;
p = arr;
max = *p;
p++;
while (p < arr + 8)
{
if (*p > max)
{
max = *p;
p++;
}
else
max = max;
p++;
}
printf("%d", max);
return 0;
}
四. const关键字
1.const介绍
C语言中提供了const关键字,const 中文意思是“恒定的”,从字面意思不难理解,它可以使其修饰的对象变得“恒定”,也就是不能改变。当开发者有意无意地改变被const修饰的对象时,编译器就会报错,使得代码的问题在编译阶段就能被发现,从而提高了开发的效率。
2.const修饰局部变量
int const n = 1;
const int n = 1;
3.const修饰指针变量
在const修饰局部变量时,变量将变得不可修改。但如果绕过变量,使用局部变量的地址,就可以修改掉局部变量的值,这显然不符合我们的需求,所以想要使变量的值无法通过指针改变时,可以使用const修饰指针变量。它又分为一下几种情况:
int a = 1;
int b = 1;
int c = 1;
//const 在*的左边
int const* p1 = &a;
//const 在*的右边
int* const p2 = &b;
//const 在*的两侧都有
int const* const p3 = &c;
- 当const在*左边时,不能通过解引用指针变量来修改指针所指向的变量。
- const在*右边时,不能改变指针变量内存储的地址。
- const在*两侧都有时,既不能通过解引用指针变量来修改所指向的变量,也不能改变指针变量所指向的地址。
- 所以,如果我们想要一个局部变量彻底的无法被修改,需要在定义时使用const修饰变量,同时使用const在*左边修饰指向这个变量的指针变量。
代码实现
//const 的学习
//1 const修饰的
#include <stdio.h>
int main()
{
const int p = 9;
const int* pa = &p;
printf("%d\n", *pa);// const int (里面放什么什么不能修改)=();
int q = 8; // const int q=1;/// *p无法修改可以改变p地址的值来间接改变*p
pa = &q; // *pa=&q
printf("%d\n", *pa); // printf("%d",*q);
return 0;
}
//2被const 修饰的
#include <stdio.h>
int main()
{
int a = 9;
int* const pa = &a;// 这种情况不能改地址&a只能改指向的&a的a的数值
a = 8;
printf("%d", *pa);
return 0;
}
//3
const int* const pa = &a;
有不正确的地方欢迎各路大佬指出。
-----点个关注不迷路-------