C++学习：第二章C语言基础 - （十四）指针

最新推荐文章于 2024-03-12 12:21:09 发布

Thomas会写字

最新推荐文章于 2024-03-12 12:21:09 发布

阅读量463

点赞数 1

分类专栏： C++

共享知识，欢迎转载

本文链接：https://blog.csdn.net/kakiebu/article/details/82881787

版权

C++ 专栏收录该内容

67 篇文章 6 订阅

订阅专栏

1. 地址与指针

首先要明白，每个变量存放都有一个唯一的内存编码，成为该变量的存放地址

而存放地址类型的变量则称为指针，有些地方就直接把地址成为指针，这点需要注意下

地址不是孤立的，总是伴随着变量类型，

#include <stdio.h>

int main(){

    char x[9] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};
    puts(x);

    //两种初始化方法
    char* p1;
    p1 = &x[0];
    char* p2 = &x[1];
    printf("%c\n", *p1);

    //通过指针改变原变量值
    *p1 = 'A';
    *p2 = 'B';
    puts(x);

    //指针类型与数据类型不同时的报错情况
    int* p3 = (int*)&x[4];
    printf("%X\n",*p3);

    //练习代码
    //通过指针改变原变量值
    //指针类型和数据类型对应练习
    char a = 'a';
    printf("%c\n", a);

    char* p1 = &a;
    printf("%c\n", *p1);

    *p1 = 'A';
    printf("%c\n", a);
    printf("%c\n", *p1);

    int b = 1;
    printf("%d\n", b);

    int* p2 = &b;
    printf("%d\n", *p2);

    *p2 = 2;
    printf("%d\n", b);
    printf("%d\n", *p2);

    getchar();

    return 0;
}

上段代码说明了一下几点：

要注意vs2010只支持到C89标准，所有变量需要放在前面，因此会报错。要么去Linux下要么将文件改成.cpp。
存放地址的数据类型是char*，刚好是1字节8位，与地址的长度相等，如果用int*就会出问题，因为int*是4字节32为，刚好使4个地址的长度，依据不同编译器的差异，会有向前或向后两种取值方法，取足4个地址存放到int* 中。
char* 是数据类型，这里的*表示数据类型，*p1表示寻址，因此寻址还是数据类型看*前是否有变量类型，*后是否有变量名称。
char类型数据的指针是char*，int类型数据的指针是int*。
声明未初始化的指针成为野指针，指向未知地方，危险。

#include <stdio.h>

int main(){

    int a=0,b=1;

    int*p=&a, q=&b;

    getchar();

    return 0;
}

这样写不对，公共的类型名只有第一个，因此认为p是int*，而q是int型，因此如果正确写法是 int* p=&a, * q=&b;

2. 数组与指针

#include <stdio.h>

void tt(int* a, int n){

	printf("%d\n", *(a+n));
}

int main()
{
	int a[3] = {1,2,3};
	tt(a, 0);

    int x[5] = {11,22,33,44,55};
	int y[3][5] = {{1,2,3,4},{5,6,7},{8,9}};

	printf("%p\n", x);
	printf("%p\n", x[0]);
	printf("%p\n", &x);
	printf("%p\n", &x[0]);
	puts("");

	printf("%p\n", y);
	printf("%p\n", y[0]);
	printf("%p\n", &y);
	printf("%p\n", &y[0]);
	puts("");
	
	getchar();
	return 0;
}

#include<stdio.h>
#include <string.h>

int main(){

	char a[100] = {'a', 'b', '\0', 'c', 'd'};

	"csd";//这么写等价于 const char[8]，是静态的，常量，不可修改

	puts(a);//输出 ab
	puts("csd");//输出 csd

	char* p = a;
	printf("000 %c\n", *p);//输出 a ，因为是 %c ，不是 %s ,%s 输出为ab

	/*
		这么写是正确的，因为p指向的地址(a数组)是可修改的
		这样写相当于是把a数组的第一个元素a改为w
		因为a数组的地址和a数组第一个元素的地址是一样的
		因此 *p = 'w' 就等价于 a[0] = 'w'
	*/
	*p = 'w';
	puts(a);
	
	a[0] = 's'; 
	puts(a);

	/*
		这个写法说明：
		1. 变量存储地址是不变的，改的是值
		2. 指针指向的是数组首地址，所以两个结果是一样的
		3. 遇到\0就结束，后面的不输出
	*/
	strcpy(a, "lingyige\0ceshi");
	puts(a);//输出 lingyige
	puts(p);//输出 lingyige

	p = "opw";//重新指向了另一个数组，注意这个数组是静态的，有的编译器可能会有警告
	printf("000 %c\n", *p);
		

	/*
	*p = 'e';//编译通过，运行报错，不能给常量赋值

	//赋值为空，避免野指针
	//这里要注意，是q指向的目标是字符常量而不是说q是字符常量
	//因此可以理解为不会通过指针来改变数组数据

	// const char* q = NULL; 等价于 char const* q = NULL;
    // 这是说不能通过q去修改q指向的内容
	// const char* q = NULL; 不等价于 char* const q = NULL;
	// 这是说q的内容不可以修改
	const char* q = NULL;	

	q = "opw";//不同于上面的写法，这样写一定是安全的

	*q = 'y';//编译时就会报错，不能给常量赋值。
	*/


	getchar();

	return 0;

}

上段代码中

1. 说明了 const 修饰符在不同位置的差异

2. 说明了静态字符串与指针和修改的问题

#include<stdio.h>

int main(){

	/*
		1. 这里没有保存任何一个字符串
		2. 这里只是保持了9个字符串的开始地址
		3. 这9个地址指向只读存储区，各指向一个数组（这9个字符串是静态不可修改的）
		4. 每个数组都有个\0
		5. 每个数组地址间隔4字节，因为每个地址用4字节的存储空间
	*/
	char* name[9] = {"0abc", "1def", "2ghi", "3lmn", "4opq", "5rst", "6lkt", "7uvw", "8xyz"};

	for (int i=0; i<9; i++)	{
		puts(name[i]); }

	printf("%d\n", &name[0]);
	printf("%d\n", &name[1]);
	printf("%d\n", &name[2]);
	printf("%d\n", &name[3]);

	
	/*
		1. 对不可修改的内容排序
	*/
	const int  a=10, b=30, c=60, d=23, e=55, f=89;
	const int* p[6] = {&a, &b, &c, &d, &e, &f};
	for (int i=0; i<6; i++)	{
		for(int j=i+1; j<6; j++){
			if (*p[j] > *p[i]){
				const int* t=p[j];
				p[j] = p[i];
				p[i] = t;
			}
		}
	}

	for (int i=0; i<6; i++)	{
		printf("%d\n", *p[i]); }

	getchar();

	return 0;

}

3. 二级指针

#include<stdio.h>
#include <ctype.h>

int str2int(const char* str, const char** pp){
	int r = 0;
	while (isdigit(*str)) {
		r = r*10 + *str - '0';
		str ++;
	}
	*pp = str;
	return r;
}

int main(int argc, char* argv[]){

	const char* p = NULL;
	/*
		这里解释下为什么是 &p 而不是 p
		如果是p作为实参传参，函数那边接收到的是 p 的值
		虽然 p 的值也是一个地址但是问题是函数传参时
		它的值是复制过去的，因此无论函数那边如何改变都不可能改变 p 的值
		因此只能够通过地址，因为 p 是一级指针，因此函数端需要二级指针
	*/
	int n = str2int("3534asd", &p);
	printf("%d\n", n);
	printf("%s\n", p);

	getchar();

	return 0;

}

4. 无法确定类型的函数指针传参

#include<stdio.h>
#include <ctype.h>

/*
	函数说明：
	1. 此处传的是指针，而指针是有类型的，但这里不知道具体的指针类型，因此可以用void*
	2. void*无法直接使用，因为他没有数据类型，因此使用之前需要强制类型转换
	3. 这里是读取每个字节的内容，因此强转为 unsigned char* 数据类型
	4. len -- > 0 ： 先循环，再减一
	5. (*(unsigned char*)ptr)++ ： 先强转为 unsigned char* ，然后指针读取数值， 然后 printf 输出， 然后指针++
	6. %02X ： 按照16进制输出，每次输出2位，不足2位用0补齐
*/

void showbytes(void* ptr, int len){
	
	while(len -- > 0)
		printf("%02X ", (*(unsigned char*)ptr)++);
	printf("\n");
}

int main(int argc, char* argv[]){

	int     n = 1234567890;
	float	f = 1234567890;
	double	d = 1234567890;
	//这里会溢出，不同编译器处理方法不同，我这里测试的是截断，只保留最后两个字节
	short	s = 1234567890;

	showbytes(&n, sizeof(n));
	showbytes(&f, sizeof(f));
	showbytes(&d, sizeof(d));
	showbytes(&s, sizeof(s));

	getchar();

	return 0;

}