深入浅出C指针，细节之处见真章，拒绝一切无病呻吟！！！

#include<iostream>
using namespace std;

int main() {
	int* p;	//这里这个星号是声明指针
	int a = 10;
	p = &a;
	cout << *p << endl;	//这里这个星号就是解引指针
}

/*以int指针做实验*/

#include<iostream>
using namespace std;

int main() {
	int* p;
	int a = 10;
	p = &a;
	cout << p << endl;
	cout << p+1 << endl;
	cout << p+2 << endl;
	cout << p+3 << endl;
}

004FFD34
004FFD38
004FFD3C
004FFD40

/*以char指针做实验*/

#include<iostream>
using namespace std;

int main() {
	char* p;
	char a = 10;
	p = &a;

	printf("%p\n", p);
	printf("%p\n", p+1);
	printf("%p\n", p+2);
	printf("%p\n", p+3);
}

00B5FA2B
00B5FA2C
00B5FA2D
00B5FA2E

int main() {

	const int a = 10;
	int b = 0;

	const int* p = &a;	//这是一个指向整数常量的指针、
	//int* pp = &a;	//无法将一个const int* 对象赋值给int*

	p = &b;	//将指针指向另一个对象
	//*p = 100;	//表达式必须有一个可以修改的左值
	//我们可以用p来解引用，但是不能用p来修改它，即使它是一个普通变量
	//因为它认为自己指向的是一个整数常量，服不服？！

	int* pp = &b;
	*pp = 100;

}

p可以被修改为指向不同的常量
p可以被修改为指向不同的变量
可以解引用以读取数据
不能解引从而修改它指向的数据

#include<iostream>
using namespace std;

int main() {
	int a = 10;
	int b = 0;

	int* const p = &a;	//这是一个指向变量的常量指针、

	//p = &b;	//将指针指向另一个对象
	//表达式必须有一个可以修改的左值
	
	*p = 100;	//可以对p进行解引用以修改所指向地址内的内容
}

p被初始化为指向变量的常量指针
p不能指向其它对象
p指向的数据可以被修改

struct text* a;	//这是一个结构体对象
···

//现在，需要初始化一块空间，将结构体内容写入进行网络传输

//方案一：
char* str_a = new(sizeof(a));		

//方案二：
char* str_a = new(sizeof(struct text));

//站在一个小白的角度，这两个方案你们怎么选？

malloc：从堆上分配内存
calloc：从堆上分配内存并清零
realloc：在之前分配内存的基础上，将内存重新分配为更大或更小的部分
free：将内存块返回堆

double *d = (double*)malloc(10*sizeof(malloc));

double *d = (double*)malloc(10*sizeof(malloc));
if(d!=NULL){	//如果分配空间成功
	memset(d,0,10);		//清空所分配的空间
	···
}

void* realloc(void*ptr,size_t size);

void My_Free(void **p){
	//这是一个我们自己的free函数
	//1、防止指针被回收但是指向的内存没有释放
	//2、防止重复释放指针
	if(p != NULL && *p != NULL){	
		free(*p);
		*p = NULL;
	}
}

可能很耗时，释放复杂结构也比较麻烦
可能增加应用程序的大小
增加更多编程错误的概率

char* forget(){
	//函数名字忘了，参数啥的也都忘了，核心是记住了
	char* res = new char[100];
	sprintf(···);
	return res;
}

自定义排序/搜索

不同的模式（如策略，观察者）

回调

//节点描述结构体
typedef struct point
{
	void *pData;				//指向数据域
	struct point *next;			//指向下一个节点	
} POINT_T;

//节点数据结构体
typedef struct test
{	
	char name[12];		//名字
	char pwd[8];		//密码
	int number;			//编号
	int flag;			//区分管理员和用户	// 	0 超级管理员 1 管理员  2 普通用户 3 屏蔽用户
	int money;			//仅用户有存款，初始500
} TEST_T;

(伪代码)
PData* head;	//链表的头
PData* tempA = head;	//临时节点，但是它现在也是链表的头了
PData* tempB = head;	//临时节点，但是它现在也是链表的头了

tempA = tempA->next;	
//将tempA指针指向下一个节点，失去了对原地址的决定权，但是保留了对原地址的下一个地址的绝对权力。另外两个指针并不受影响
tempB->next = NULL;		
//好家伙，tempB指针将当前地址的下一个指针域置空了，由于tempA已经走了，所以不受影响，但是head指针指向的部分同时被清空了

head->next = tempA;	
//将tempA接到了head的下面，原本A后面的内容就没有掉了
//但是，tempA也受到了影响，这句话等同于：
head->next = head;
//陷入了死循环

head->val = 0;	
//将head指针指向的值域的值置0，则tempA、tempB所指向值域的值读出来也是0了。

//创建结点
POINT_T * creat(void *data )	//创建一个属于结构体point的函数，
//传入结构体test的指针便可以用以操作test变量，
{								//并返回一个point的指针用以操作point函数
	POINT_T *p=NULL;
	
	p=(POINT_T *)malloc(sizeof(POINT_T));
	if(p==NULL)
	{
		printf("申请内存失败");
		exit(-1);
	}
	memset(p,0,sizeof(POINT_T));
	
	p->pData=data;
	p->next=NULL;	//处理干净身后事
	return p;
}

//新增节点
void add(POINT_T * the_head,void *data )				//这里的data不会和上面那个冲突吗？
{
	POINT_T * pNode=the_head;							//把头留下
	POINT_T *ls=creat(data);
	//后面再接上一个
	while (pNode->next != NULL)							//遍历链表，找到最后一个节点
	{
		pNode=pNode->next;
	}
	pNode->next=ls;			//ls 临时
}

//删除节点
void del(POINT_T * the_head, int index)
{
	POINT_T *pFree=NULL;					//用来删除
	
	POINT_T *pNode=the_head;
	int flag=0;
	while (pNode->next!=NULL)
	{
		if(flag==index-1)
		{
			pFree=pNode->next;				//再指向数据域就爆了
			pNode->next=pNode->next->next;	//这里要无缝衔接
			free(pFree->pData);				//先释放数据
			free(pFree);					//释放指针
			break;
		}
		pNode=pNode->next;
		flag++;	
	}	
}

//计算节点数
int Count(POINT_T * the_head)
{
	int count=0;
	POINT_T *pNode1=the_head;
	while (pNode1->next!=NULL)
	{
		pNode1=pNode1->next;
		count++;		
	}	
	return count;
}

//查找固定节点数据
POINT_T * find(POINT_T *the_head,int index)
{
	int f=0;
	POINT_T *pNode=NULL;
	int count=0;
	pNode=the_head;
	
	count=Count(the_head);
	
	if(count<index)	
		printf("find nothing");
	
	while(pNode->next!=NULL)
	{
		if(index==f)
			return pNode;
		pNode=pNode->next;
		f++;		
	}
}