[C语言]初阶指针和结构体
初阶指针和结构体：：
指针
1.指针概述
内存
内存含义：
存储器：计算机的组成中，用来存储程序和数据，辅助CPU进行运算处理的重要部分。
内存：内部存储器，暂存程序/数据——掉电丢失 SRAM,DRAM,DDR,DDR2,DDR3。
外存：外部存储器。长时间保存程序/数据——掉电不丢失ROM，ERRROM，FLASH(NAND,NOR),硬盘，光盘。
内存是沟通CPU与硬盘的桥梁：
1.暂存放CPU中的运算数据 2.暂存与硬盘等外部存储器交换的数据。
物理存储器和存储地址空间
有关内存的两个概念：物理存储器和存储地址空间。
物理存储器：实际存在的具体存储器芯片。
1.主板上装插的内存条 2.显示卡上显示的RAM芯片 3.各种适配卡上的RAM芯片和ROM芯片
存储地址空间：简单来说就是对存储器编码的范围。我们在软件上常说的内存就是指这一层含义
1.编码：对每个物理存储单元(一个字节)分配一个号码
2.寻址：可以根据分配的号码找到相应的存储单元，完成数据的读写
内存地址
1.将内存抽象成一个很大的一堆字符数组。
2.编码就是对内存的每一个字节分配一个32位或64位的编号(与32位或者64位处理器相关)。
3.这个内存编号我们称之为内存地址：
char：占一个字节分配一个地址 int：占4个字节分配4个地址 float,struct,函数,数组等
指针和指针变量
内存区的每一个字节都有一个编号，这就是地址。如果在程序中定义了一个变量，在对程序进行编译或运行时，系统就会给这个变量分配内存单元，并确定它的内存地址(编号)。指针的实质就是内存地址，指针就是地址，地址就是指针。指针是内存单元的编号，指针变量就是存放地址的变量。
通常我们叙述时会把指针变量简称为指针。
2.指针基础知识
指针变量的定义和使用
1.指针也是一种数据类型，指针变量也是一种变量
2.指针变量指向谁，就把谁的地址赋值给变量
3.” * “操作符操作的是指针变量指向的内存空间
总之：指针是内存中最小单元的编号，也就是地址。平时口语中说的指针，通常指的就是指针变量，是用来存放内存地址的变量。即指针就是地址，口语中的指针通常指的就是指针变量。
#include <stdio.h>
int main()
{
int a = 0;
char b = 100;
printf("%p, %p\n", &a, &b); 打印a, b的地址
int*代表一种数据类型，int*指针类型，p才是变量名
定义了一个指针类型的变量，可以指向一个int类型变量的地址
int *p;
p = &a;将a的地址赋值给变量p，p也是一个变量，值是一个内存地址编号
printf("%d\n", *p);p指向了a的地址，*p就是a的值
char *p1 = &b;
printf("%c\n", *p1);*p1指向了b的地址，*p1就是b的值
return 0;
}注意：&可以取得一个变量在内存中的地址。但是，不能取寄存器变量，因为寄存器变量不在内存里而在CPU里，所以是没有地址的。
通过指针间接修改变量的值
int a = 0;
int b = 11;
int *p = &a;
*p = 100;
printf("a = %d, *p = %d\n", a, *p);
p = &b;
*p = 22;
printf("b = %d, *p = %d\n", b, *p);指针大小
指针变量是用来存放地址的变量(存放在指针的值都被当成地址处理)
那么就出现两个问题：1.一个小的单元到底是多大？(一个字节) 2.如何编址？
经过仔细的计算和权衡我们发现一个字节给一个对应的地址是比较合适的。对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平(高电压)和低电平(低电压)就是1或者0.
那么32根地址线产生的地址就会是：
这里就有2的32次方个地址。每个地址标识一个字节，那我们就可以给(2^32byte == 2^32/1024KB == 2^32/1024/1024MB == 2^32/1024/1024/1024GB == 4GB)4G的空间进行编址。同样的方法，64位机器也可计算求得。
这里我们就明白：
1.在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节。
2.那么在64位机器上，如果有64个地址线，那一个指针变量的大小就是8个字节才能存放一个内存地址。
总之：
1.指针是用来存放地址的，地址是唯一标示一块地址空间的，即一个无符号的十六进制整型数。
2.指针的大小在32位平台是4个字节，在64位平台是8个字节。
指针类型不能混用的原因：
结论1：指针类型决定了指针在被解引用的时候访问几个字节，如果是int*的指针，解引用访问4个字节，如果是char*的指针，解引用访问1个字节。所以，指针类型的不同在存放时不会产生问题，但不同的指针类型大小决定了解引用时访问几个字节。
结论2：指针的类型决定了指针+-1操作的时候，跳过几个字节，即决定了步长。
int* 和 float* 指针不能混用的原因：
虽然二者访问的变量大小都是4个字节，但int* 访问的是整型数据，是以整型的存储方式存储在内存中的，float* 访问的是浮点型数据，是以浮点型的数据存储在内存中的。
3.野指针和空指针
野指针和空指针的定义
野指针的定义是指针变量指向一个未知的空间，指针变量也是变量，是变量就可以任意赋值，不要越界即可(32位为4字节，64位为8字节)，但是任意数值赋值给指针变量没有意义，因为这样的指针就成了野指针，此指针指向的区域是不可控的(操作系统不允许操作此指针指向的内存区域)。所以，野指针不会直接引发错误，即野指针不解引用是不会造成危险的，操作野指针指向的内存区域才会出问题。但是野指针和有效指针变量保存的都是数值，为了标志此指针变量没有指向任何变量(空闲可用)，C语言中可以把NULL赋值给此指针，空指针是指内存地址编号为0的空间。
注：操作系统将0-255作为系统占用，不允许访问操作，因此不建议将一个变量的值直接赋值给指针变量。
int a = 100;
int *p;
p = a; 把a的值赋值给指针变量p，p为野指针， ok，不会有问题，但没有意义
p = 0x12345678; 给指针变量p赋值，p为野指针， ok，不会有问题，但没有意义
*p = 1000; 操作野指针指向未知区域，内存出问题，err野指针成因
1.指针未初始化 2.指针越界访问 3.指针指向的空间释放
#include <stdio.h>
int main()
{
int *p;局部变量指针未初始化，默认为随机值
*p = 20;
return 0;
}
#include <stdio.h>
int main()
{
int arr[10] = {0};
int *p = arr;
int i = 0;
for(i=0; i<=11; i++)
{
当指针指向的范围超出数组arr的范围时，p就是野指针
*(p++) = i;
}
return 0;
}
#include<stdio.h>
int* test()
{
int a = 10;
return &a;
}
int main()
{
int*p = test();
return 0;
}
因此函数返回时不可以函数局部变量的地址如何规避野指针
1.指针初始化 2.小心指针越界 3.指针指向空间释放即时置为NULL 4.避免返回局部变量的地址
5.指针使用之前检查有效性
#include <stdio.h>
使用之前检查指针有效性
int main()
{
int *p = NULL;
int a = 10;
p = &a;
if(p != NULL)
{
*p = 20;
}
return 0;
}4.万能指针与const修饰的指针变量
万能指针
void*指针可以指向任意变量的内存空间：在内存中 void*占四个字节大小，因此万能指针可以接收任意类型变量的内存地址，但最好将其强制转换为void*,也可以通过万能指针修改变量的值，但是修改变量的值时需要找到变量对应的指针类型。
int a = 10;
void *p = NULL;
p = (void *)&a; 指向变量时，最好转换为void *
使用指针变量修改变量值时，转换为int *
*( (int *)p ) = 11;
printf("a = %d\n", a);const修饰指针变量
1.const修饰普通变量变为常量：可以通过指针间接修改常量的值
2.const修饰指针类型：可以修改指针变量的值，但不可以修改指针变量指向内存空间的值
3.const修饰指针变量：可以修改指针变量指向内存空间的值，不可以修改指针变量的值
4.const修饰指针类型修饰指针变量：只读指针 只能通过二级指针来修改
int a = 100;
int b = 200;
指向常量的指针
修饰*，指针指向内存区域不能修改，指针变量可以改
const int * p1 = &a; 等价于int const *p1 = &a;
*p1 = 111; err
p1 = &b; ok
指针常量
修饰p1，指针变量不能改，指针指向的内存区域可以修改
int * const p2 = &a;
p2 = &b; //err
*p2 = 222; //ok
通过二级指针来改变只读指针的值
const int* const p = &a;
int** p = &p;
*pp=&b;在编辑程序时，指针作为函数参数，如果不能修改指针对应内存空间的值，需要使用const修饰指针数据类型。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void)
{
const修饰一个变量为只读
const int a = 10;
a = 100; //err
指针变量， 指针指向的内存， 2个不同概念
char buf[] = "aklgjdlsgjlkds";
从左往右看，跳过类型，看修饰哪个字符
如果是*， 说明指针指向的内存不能改变
如果是指针变量，说明指针的指向不能改变，指针的值不能修改
const char *p = buf;
等价于上面 char const *p1 = buf;
p[1] = '2'; err
p = "agdlsjaglkdsajgl"; ok
char * const p2 = buf;
p2[1] = '3';ok
p2 = "salkjgldsjaglk"; err
p3为只读，指向不能变，指向的内存也不能变
const char * const p3 = buf;
return 0;
}5.指针运算
指针+-整数
如果是一个int*,+1的结果是增加一个int的大小。
如果是一个char*,+1的结果是增加一个char的大小。
#include <stdio.h>
int main()
{
int n = 10;
char *pc = (char*)&n;
int *pi = &n;
printf("%p\n", &n);
printf("%p\n", pc);
printf("%p\n", pc+1);
printf("%p\n", pi);
printf("%p\n", pi+1);
return 0;
}
#include<stdio.h>
int main()
{
int a;
int *p = &a;
printf("%d\n", p);
p += 2;移动了2个int
printf("%d\n", p);
char b = 0;
char *p1 = &b;
printf("%d\n", p1);
p1 += 2;移动了2个char
printf("%d\n", p1);
return 0;
}
#include <stdio.h>
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
int *p = arr;
for (i = 0; i < sz; i++)
{
printf("%d, ", *p);
p++;
}
return 0;
}
#include <stdio.h>
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
int *p = arr+sz-1;
for (i = 0; i < sz; i++)
{
printf("%d, ", *p);
p--;
}
printf("\n");
return 0;
}
#include <stdio.h>
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int *p2 = &arr[2]; 第2个元素地址
int *p1 = &arr[1]; 第1个元素地址
printf("p1 = %p, p2 = %p\n", p1, p2);
int n1 = p2 - p1; n1 = 1
int n2 = (int)p2 - (int)p1; 第二个元素和第一个元素在内存之间相差4byte n2=4
printf("n1 = %d, n2 = %d\n", n1, n2);
return 0;
}
#define N_VALUES 5
float values[N_VALUES];
float *vp;
指针+-整数；指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{
*vp++ = 0;
}指针-指针
指针-指针得到的是内存中指针和指针之间的元素个数，但不是所有的指针都能相减，指向同一块空间的两个指针才能相减。
指针-指针模拟实现strlen
int my_strlen(char* str)
{
char* start = str;
while (*str != '\0')
{
str++;
}
return (str - start);
}
int main()
{
int len = my_strlen("abcdef");
printf("%d\n", len);
return 0;
}指针的关系运算
#define values[N_VALUES] 5
for(vp = &values[N_VALUES]; vp > &values[0];)
{
*--vp = 0;
}
将代码修改如下：
for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)
{
*vp = 0;
}实际在绝大部分的编译器上是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证 它可行。
标准规定：
允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。
6.指针和数组
结论:数组名表示的是数组首元素的地址。既然可以把数组名当成地址存放到一个指针中，我们使用指针来访问就成为可能。例如：
#include <stdio.h>
int main()
{
int arr[] = {1,2,3,4,5,6,7,8,9,0};
int* p = arr; 指针存放数组首元素的地址
int sz = sizeof(arr)/sizeof(arr[0]);
for(i=0; i<sz; i++)
{
printf("&arr[%d] = %p <====> p+%d = %p\n", i, &arr[i], i, p+i);
}
return 0;
}运行结果如下：
所以p+i其实计算的是数组arr下标为 i 的地址.
那我们就可以直接通过指针来访问数组。如下：
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
int *p = arr; 指针存放数组首元素的地址
int sz = sizeof(arr) / sizeof(arr[0]);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ",*(p+i));
}
return 0;
}7.二级指针
一级指针用来存放变量的地址，二级指针则用来存放一级指针的地址
一级指针+偏移量相当于跳过了一个元素，二级指针+偏移量相当于跳过了一个一维数组的大小
二级指针的运算：
1.*ppa通过对ppa的地址进行解引用，这样找到的是pa，*ppa其实访问的就是pa.
2.**ppa先通过*ppa找到pa，然后对pa进行解引用操作，那找到的就是a.
int b = 20; *ppa = &b;等价于 pa = &b;
**ppa = 30;
等价于*pa = 30;
等价于a = 30;8.指针数组
指针数组，它是数组，是存放指针的数组，数组的每个元素都是指针类型。
指针数组是一个特殊的二维数组模型
打印二维数组
int main()
{
int arr[3][4] = { 1,2,3,4,2,3,4,5,3,4,5,6 };
for (i = 0; i < 3; i++)
{
for (j = 0; j < 4; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
return 0;
}
指针数组模拟二维数组
int main()
{
int arr1[4] = { 1,2,3,4 };
int arr2[4] = { 2,3,4,5 };
int arr3[4] = { 3,4,5,6 };
int* parr[3] = {arr1, arr2, arr3};
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 4; j++)
{
printf("%d ", parr[i][j]);
}
printf("\n");
}
return 0;
}9.指针和函数
函数形参改变实参的值
值传递：形参不影响实参的值
地址传递：形参可以改变实参的值
#include <stdio.h>
void swap1(int x, int y)
{
int temp = 0;;
temp = x;
x = y;
y = temp;
printf("x = %d, y = %d\n", x, y);
}
void swap2(int* x, int* y)
{
int temp = 0;
temp = *x;
*x = *y;
*y = temp;
}
int main()
{
int a = 3;
int b = 5;
swap1(a, b); 值传递
printf("a = %d, b = %d\n", a, b);
a = 3;
b = 5;
swap2(&a, &b); 地址传递
printf("a2 = %d, b2 = %d\n", a, b);
return 0;
}数组名作为函数参数 数组名作为函数参数，函数的形参会退化为指针
#include <stdio.h>
void printArrary(int* arr, int n)
{
int i = 0;
for (i = 0; i < n; i++)
{
printf("%d, ", arr[i]);
}
printf("\n");
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int n = sizeof(arr) / sizeof(arr[0]);
数组名做函数参数
printArrary(arr, n);
return 0;
}指针作为函数的返回值
#include <stdio.h>
int a = 10;
int* getA()
{
return &a;
}
int main()
{
*( getA() ) = 111;
printf("a = %d\n", a);
return 0;
}10.指针和字符串
字符指针
#include <stdio.h>
int main()
{
char str[] = "hello world";栈区字符串 可修改
char* p = str;
*p = 'm';
p++;
*p = 'i';
printf("%s\n", str);
p = "mike jiang";
printf("%s\n", p);
char* q = "test";数据区常量字符串 不可修改
printf("%s\n", q);
return 0;
}字符指针作为函数参数
#include <stdio.h>
字符串追加
void mystrcat(char *dest, const char *src)
{
int len1 = 0;
int len2 = 0;
while (dest[len1])
{
len1++;
}
while (src[len2])
{
len2++;
}
int i = 0；;
for (i = 0; i < len2; i++)
{
dest[len1 + i] = src[i];
}
}
int main()
{
char dst[100] = "hello mike";
char src[] = "123456";
mystrcat(dst, src);
printf("dst = %s\n", dst);
return 0;
}指针数组作为main函数的形参
int main(int argc,char* argv[])1.main函数是操作系统调用的，第一个参数标明argc数组的成员数量，argv数组的每个成员都是char* 类型.
2.argv是命令行参数的字符串数组.
3,argc代表命令行参数的数量，程序名字本身算一个参数.
#include <stdio.h>
argc: 传参数的个数（包含可执行程序）
argv：指针数组，指向输入的参数
int main(int argc, char *argv[])
{
指针数组，它是数组，每个元素都是指针
char *a[] = { "aaaaaaa", "bbbbbbbbbb", "ccccccc" };
int i = 0;
printf("argc = %d\n", argc);
for (i = 0; i < argc; i++)
{
printf("%s\n", argv[i]);
}
return 0;
}结构体
1.结构体类型的声明
1.结构的基础知识：
结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。
2.结构的声明：
typedef struct Stu
{
char name[20];名字
int age;年龄
char sex[5];性别
char id[20];学号
}Stu；分号不能丢3.结构成员的类型
结构成员可以是标量，数组，指针甚至是其他结构体
4.结构体变量的定义和初始化
struct Peo
{
char name[20];
char tele[12];
char sex[5];
int high;
};
struct St
{
struct Peo p;结构体嵌套结构体
int num;
float f;
};
int main()
{
struct Peo p1 = {"张三", "15596668862", "男", 181};结构体变量的创建
struct St s = { {"lisi", "15596668888", "女", 166}, 100, 3.14f};
printf("%s %s %s %d\n", p1.name, p1.tele, p1.sex, p1.high);
printf("%s %s %s %d %d %f\n", s.p.name, s.p.tele, s.p.sex, s.p.high, s.num, s.f);
return 0;
}2.结构体初始化
结构体变量访问成员是通过点操作符( . )访问的，点操作符接受两个操作数.
代码1
struct S s;
strcpy(s.name, "zhangsan");使用.访问name成员
s.age = 20;使用.访问age成员
代码2
struct Stu
{
char name[20];
int age;
};
void print(struct Stu* ps) {
printf("name = %s age = %d\n", (*ps).name, (*ps).age);
使用结构体指针访问指向对象的成员
printf("name = %s age = %d\n", ps->name, ps->age);
}
int main()
{
struct Stu s = {"zhangsan", 20};
print(&s);结构体地址传参
return 0;
}3.结构体传参
struct Peo
{
char name[20];
char tele[12];
char sex[5];
int high;
};
struct St
{
struct Peo p;
int num;
float f;
};
void print1(struct Peo p)
{
printf("%s %s %s %d\n", p.name, p.tele, p.sex, p.high);//结构体变量.成员变量
}
void print2(struct Peo* sp)
{
printf("%s %s %s %d\n", sp->name, sp->tele, sp->sex, sp->high);//结构体指针->成员变量
}
int main()
{
struct Peo p1 = {"张三", "15596668862", "男", 181};//结构体变量的创建
struct St s = { {"lisi", "15596668888", "女", 166}, 100, 3.14f};
printf("%s %s %s %d\n", p1.name, p1.tele, p1.sex, p1.high);
printf("%s %s %s %d %d %f\n", s.p.name, s.p.tele, s.p.sex, s.p.high, s.num, s.f);
print1(p1);
print2(&p1);
return 0;
}上面的print1和print2函数哪个好些？
答：优选print2函数.
原因：函数传参的时候参数是需要压栈的，如果传递一个结构体对象的时候，结构体过大，参数压栈的系统开销过大，会导致性能的下降.
结论：结构体传参的时候，要传结构体的地址.
C语言编程训练(牛客网)
1.BC51——三角形判断
#include <stdio.h>
int main()
{
int a = 0;
int b = 0;
int c = 0;
while(scanf("%d %d %d",&a,&b,&c) == 3)
{
if((a+b>c) && (a+c>b) &&(b+c>a))
{
if(a==b && b==c)
{
printf("Equilateral triangle!\n");
}
else if((a==b && b!=c)||(a==c && c!=b)||(b==c && b!=a))
{
printf("Isosceles triangle!\n");
}
else
{
printf("Ordinary triangle!\n");
}
}
else
{
printf("Not a triangle!");
}
}
return 0;
}2.BC54——获得月份天数
#include <stdio.h>
int is_leap_year(int y)
{
逻辑操作符如果是真就是1 如果是假返回0
return (((y%4==0)&&(y%100!=0))||(y%400==0));
}
int main()
{
int year = 0;
int month = 0;
int date = 0;
int days[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
while(scanf("%d%d",&year,&month)!=EOF)
{
date = days[month];
if(is_leap_year(year)==1 && (month==2))
{
date++;
}
printf("%d\n",date);
}
return 0;
}3.BC68——X型图案
#include <stdio.h>
思路:构建一个带空格的矩形阵
int main()
{
int n = 0;
while(scanf("%d",&n)!=EOF)
{
int i = 0;
int j = 0;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(i==j)
printf("*");
else if(i+j==n-1)
printf("*");
else
printf(" ");
}
printf("\n");
}
}
return 0;
}4.统计二进制中1的个数
代码1
int count_num_of_1(unsigned int n)
{
int count = 0;
while (n)
{
if ((n % 2) == 1)
{
count++;
}
n /= 2;
}
return count;
}
int main()
{
int num = 0;
scanf("%d", &num);
int n = count_num_of_1(num);
printf("%d\n", n);
return 0;
}
代码2
int count_num_of_1(int n)
{
int i = 0;
int count = 0;
for (i = 0; i < 32; i++)
{
if ((n >> i) & 1 == 1)
{
count++;
}
}
return count;
}
int main()
{
int num = 0;
scanf("%d", &num);
int n = count_num_of_1(num);
printf("%d\n", n);
return 0;
}
代码3
n=n&(n-1),每进行一次 就让最右边的1去掉一个 直到变成全0
判断一个数是不是2的n次方
2的n次方的二进制数只有一个1 那么if(n&(n-1)==0)就说明n是2的n次方
int count_num_of_1(int n)
{
int count = 0;
while (n)
{
n = n & (n - 1);
count++;
}
return count;
}
int main()
{
int num = 0;
scanf("%d", &num);
int n = count_num_of_1(num);
printf("%d\n", n);
return 0;
}5.求两个数二进制中不同位的个数
代码1
int count_diff_bit(int m, int n)
{
int count = 0;
int i = 0;
for (i = 0; i < 32; i++)
{
if (((m >> i) & 1) != ((n >> i) & 1))
{
count++;
}
}
return count;
}
int main()
{
int m = 0;
int n = 0;
scanf("%d %d", &m, &n);
int ret = count_diff_bit(m, n);
printf("%d\n", ret);
return 0;
}
代码2
按位异或 相同为0 相异为1
int count_diff_bit(int m, int n)
{
int count = 0;
int ret = m ^ n;
while (ret)
{
ret = ret & (ret - 1);
count++;
}
return count;
}
int main()
{
int m = 0;
int n = 0;
scanf("%d %d", &m, &n);
int ret = count_diff_bit(m, n);
printf("%d\n", ret);
return 0;
}6.打印整数二进制的奇数位和偶数位
#include<stdio.h>
int main()
{
int i = 0;
int num = 0;
scanf("%d", &num);
获取奇数位
for (i = 30; i >= 0; i -= 2)
{
printf("%d ", (num >> i) & 1);
}
printf("\n");
获取偶数位
for (i = 31; i >= 1; i -= 2)
{
printf("%d ", (num >> i) & 1);
}
return 0;
}腾讯云开发者
