指针的学习

最新推荐文章于 2023-08-29 19:43:32 发布

lucien1029

最新推荐文章于 2023-08-29 19:43:32 发布

阅读量864

点赞数

分类专栏： C语言文章标签： c语言算法

本文链接：https://blog.csdn.net/shine3316/article/details/122021755

版权

C语言专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1.认识指针

#include <stdio.h>
/*
	时间：2020/10/22 星期日
	认识指针，理解指针含义
*/
int main(void)
{
	int i = 2;
	int * p;

	p = &i;		
		/*
			1. p保存了i的地址，因此p指向了i			
			2. p不是i, i也不是p, 故 修改p的值不影响i, 修改i的值也不影响p
			3. 如果一个指针变量指向了某个普通变量，则
					*指针变量  就完全等同于  普通变量
				例子：
					如果p是个指针变量，并且p存放了普通变量i的地址
					则p指向了普通变量
					*p 就完全等价于 普通变量 
					或者说：  在所有出现*p的地方都可以替换成i
							  在所有出现i的地方都可以替换成*p

		*/

    //p = i;   //error 类型不一致，p只能存放int类型变量的地址，不能存放int类型变量的值
	//p = 55;  //error 原因同上

	printf("*p=%d\n", *p);
	printf("p=%d\n", p);
	printf("i=%d\n", i);

	return 0;
}
/*
在V C++输出结果为：
	*p=2
	p=1703740
	i=2
	Press any key to continue	
*/

2. 经典指针程序_两数互换

#include <stdio.h>
/*
	2020/11/22，星期日
	使用指针实现两个数的转换
*/
void sw_1(int * p, int * q);  //  可以使两个数互相转换
void sw_2(int * p, int * q);  //不可以使两个数互相转换
void sw_3(int * p, int * q);  //不可以使两个数互相转换
void sw_4(int a, int b)	;	  //不可以使两个数互相转换

int main(void)     //12
{
	int a = 2;
	int b = 3;
	
	sw_1(&a, &b);
	printf("a=%d, b=%d\n", a, b);  //18

	return 0;
}

void sw_1(int * p, int * q)
{
	int  t;

	t = *p;
	*p = *q;
	*q = t;
	
	return;
}

void sw_2(int * p, int * q)
{
	int * t;  //不知到t指向谁，未初始化t,t里面为垃圾值

	*t = *p;
	*p = *q;
	*q = *t;


	return;
}

void sw_3(int * p, int * q)  //该程序只是把p,q的地址互换，指向的值并没有换
{
	int * t;
	
	t = p;
	p = q;
	q = t;

	return;
}

void sw_4(int a, int b)	
{
	int t;

	t = a;
	a = b;
	b = t;

	return;
}

3.发送地址还是发送内容

/*
	2020年12月5日 星期六 图书馆
		基于通过函数完成对结构体变量的输入和输出内容的扩展：
			对于结构体变量的输出是发送地址还是发送内容
		指针的优点（发送地址）：
			快速的传递数据
			耗用内存小
			执行速度快
			由于可以接收地址会不安全（缺点）
		发送内容优缺点：
			功能单一，安全
			耗内存
*/

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

struct Student
{
	int age;
	char sex;
	char name[100];
};  //分号不能省

void InputStudent(struct Student * pstu);
void OutputStudent(struct Student ss);
int main(void)
{
	struct Student st;  // 15行
	InputStudent(&st);  //对结构体变量输入，必须发送st的地址
	OutputStudent(st);  //对结构体变量输出，可以发送st的地址，也可以发送st的内容
	printf("%d\n", sizeof(st));  //发送st的内容占用108字节
	printf("%d\n", sizeof(&st)); //发送st的内容占用4字节

	return 0;
}

void InputStudent(struct Student * pstu)  //pstu占4个字节
{
	(* pstu).age = 18;
	pstu -> sex = 'F';
	//strcpy(pstu -> sex, "男");
	strcpy(pstu -> name, "张三");	//不能写成stu.name = "张三"， 特殊格式，前面要加头文件
}

void OutputStudent(struct Student ss)
{
	printf("%d %c %s\n", ss.age, ss.sex, ss.name);	
}


/*
2021年3月22日星期一
	结构体与数组结合，函数调用

*/


4.连续存储算法演示
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>  //包含了exit函数

struct Arr        //定义了一个数据类型，该数据类型的名字叫做struct Arr,该数据类型含三个成员分别是pBase, len, cnt.
{
	int * pBase;  //存储的是数组第一个元素地址
	int len;      //数组所能容纳最大元素个数
	int cnt;      //当前数组有效元素的个数
};    //10

void init_arr(struct Arr * pArr, int length);
bool append_arr(struct Arr * pArr, int val);    //追加
bool insert_arr(struct Arr * pArr, int pos, int val);    //插入  pos的值从1开始
bool delete_arr(struct Arr * pArr, int pos, int * pVal);    //删除
int get();            //获取
bool is_empty(struct Arr * pArr);  //判断是否为空     
bool is_full(struct Arr * pArr);       //判断是否为满
void sort_arr(struct Arr * pArr);      //排序
void show_arr(struct Arr * pArr);  //显示，输出              20
void inversion_arr(struct Arr * pArr); //倒置

int main()
{
	struct Arr arr;
	int val;

	init_arr(&arr, 6);
    show_arr(&arr);
	append_arr(&arr, 1);
	append_arr(&arr, 2);
	append_arr(&arr, 3);
	append_arr(&arr, 4);
/*	if ( delete_arr(&arr, 1, &val) )
	{
		printf("删除成功！\n");
		printf("您删除的元素是：%d\n", val);
	}
	else
	{
		printf("删除失败！");
	}

	append_arr(&arr, 2);
	append_arr(&arr, 3);
	append_arr(&arr, 4);
	append_arr(&arr, 5);
	insert_arr(&arr, 1, 99);
	show_arr(&arr);

	append_arr(&arr, 7);
	show_arr(&arr);
	if ( append_arr(&arr, 7) )
	{
		printf("追加成功\n");
	}
	else
	{
		printf("追加失败\n");
	}
*/
	show_arr(&arr);
	inversion_arr(&arr);
	printf("倒置之后输出内容：\n");
	show_arr(&arr);
	sort_arr(&arr);
	show_arr(&arr);

	//printf("%d\n", arr.pBase );

    return 0;
}                       //32

void init_arr(struct Arr * pArr, int length)
{
	pArr->pBase = (int *)malloc(sizeof(int) * length);
	if (NULL == pArr->pBase)
	{
		printf("动态内存分配失败\n");
		exit(-1);    //终止整个程序
	}                  //41
	else
	{
		pArr->len = length;
		pArr->cnt = 0;
	}

	return;
}
                     //50
bool is_empty(struct Arr * pArr)
{
	if (0 == pArr->cnt)
		return true;
	else 
		return false;
}

void show_arr(struct Arr * pArr)
{                     
	if ( is_empty(pArr) )     //此处调用pArr已经是arr的地址了，不要在写成&pArr
	{
		printf("数组为空\n");
	}
	else
	{
		for (int i = 0; i<pArr->cnt; ++i)
			printf("%d ", pArr->pBase[i]);   //int *
		printf("\n");
	}                   
}  

bool is_full(struct Arr * pArr)
{
	if ( pArr->cnt == pArr->len )
		return true;
	else
		return false;
}

bool append_arr(struct Arr * pArr, int val)
{
	//满是返回false
	if ( is_full(pArr) )
	{
		return false;
	}
	//不满时追加
	pArr->pBase[pArr->cnt] = val;
	(pArr->cnt)++;
	return true; 
}

bool insert_arr(struct Arr * pArr, int pos, int val)
{
	int i;
	
	if ( is_full(pArr) )
		return false;

	if ( pos<1 || pos>pArr->cnt )
		return false;

	for ( i=pArr->cnt-1; i>=pos-1; --i)
	{
		pArr->pBase[i+1] = pArr->pBase[i];
	}
	pArr->pBase[pos-1] = val;

	return true;
}

bool delete_arr(struct Arr * pArr, int pos, int * pVal)
{
	int i;

	if ( is_empty(pArr) )
		return false;
	if ( pos<1 || pos>pArr->cnt )
		return false;

	*pVal = pArr->pBase[pos-1];
	for (i=pos; i<pArr->cnt; ++i)
	{
		pArr->pBase[i-1] = pArr->pBase[i];
	}
	pArr->cnt--;
	return true;
}
void inversion_arr(struct Arr * pArr)
{
	int i = 0;
	int j = pArr->cnt-1;
	int t;

	while (i < j)
	{
		t = pArr->pBase[i];
		pArr->pBase[i] = pArr->pBase[j];
		pArr->pBase[j] = t;
		++i;
		--j;
	}
	return;
}

void sort_arr(struct Arr * pArr)
{
	int i, j, t;

	for (i=0; i<pArr->cnt; ++i)
	{
		for ( j=j+1; j<pArr->pBase[i]; ++j)
		{
			if ( pArr->pBase[i] > pArr->pBase[j] )
			{
				t = pArr->pBase[i];
				pArr->pBase[i] = pArr->pBase[j];
				pArr->pBase[j] = t;
			}
		}
	}
}

5.1.链表的插入与删除

#include <stdio.h>

struct Node
{
	int date;             //数据域 ：存放数据
	struct Node * pNext;  //指针域 ：存放下一个节点地址
}

int main(void)
{

	return 0;
}

/*

有一个链表图，根据图理解以下两题

1. 把q指向节点插入p指向节点的后面。
方法一：r = p->pNext;      
	    p->pNext = q->pNext;
	    q->pNext = r;         
	
方法二：q->pNext = p->pNext;  表示q指向的节点 指向 p指向节点的后一个节点
		p->pNext = q;  表示p指向的节点 指向 q指向的节点
	
	  标注：p->pNext 表示p指向节点的指针域 或 p指针指向结构体中的pNext成员

2. 删除p指向节点的后一个节点。
	r = p->pNext;
	p->pNext = p->pNext->pNext;  单独写会造成内存泄漏，需要把删除节点的内存释放。java可以自动释放，c和c++需要手动释放。
	free(r);
*/

5.2.链表的插入与删除

#include <stdio.h>

struct Node
{
	int date;             //数据域 ：存放数据
	struct Node * pNext;  //指针域 ：存放下一个节点地址
}

int main(void)
{

	return 0;
}

有一个链表图，根据图理解以下两题

把q指向节点插入p指向节点的后面。
方法一：
r = p->pNext; //表示把p指向节点的下一个节点的地址赋给r
p->pNext = q->pNext; //表示把
q->pNext = r;

方法二：
q->pNext = p->pNext; //表示q指向的节点指向 p指向节点的后一个节点
p->pNext = q; //表示p指向的节点指向 q指向的节点

 注：p->pNext 表示p指向节点的指针域 或 p指针指向结构体中的pNext成员

删除p指向节点的后一个节点。
r = p->pNext;
p->pNext = p->pNext->pNext; //单独写会造成内存泄漏，需要把删除节点的内存释放。java可以自动释放，c和c++需要手动释放。
free®;

lucien1029

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
指针的学习

1.认识指针#include <stdio.h>/*时间：2020/10/22 星期日认识指针，理解指针含义*/int main(void){int i = 2;int * p;p = &i; /* 1. p保存了i的地址，因此p指向了i 2. p不是i, i也不是p, 故修改p的值不影响i, 修改i的值也不影响p 3. 如果一个指针变量指向了某个普通变量，则 *指针变量就完全等同于普通变量例子：如果p是个指
复制链接

扫一扫