开发成长之路（3）-- C语言从入门到开发（讲明白指针和引用，链表很难吗？）

&：取地址操作 
*：去引用 (间接引用)操作

int a;
int &at = a;
//上述声明允许将at和a互换，它们指向相同的值和内存单元，就像连体婴一样。

int a;
int &at;
at = a;

void swap_a(int &a,int &b)
{
	int temp;
	temp = a;
	a = b;
	b = temp;
}

//顺便来个指针的
void swap_b(int *a,int *b)
{
	int temp;
	temp = *a;	//a,b是指针，*a,*b才是int
	*a = *b;
	*b = temp;
}

int main()
{
	int a = 1;
	int b = 2;
	int c = 3;
	int d = 4;
	swap_a(a,b);	//看仔细咯，这个是引用调用
	swap_b(&a,&b);	//看仔细咯，这个是指针调用
	//如果理解不了，这样理解：参数中的*和&只是走个过场，告诉人家那个参数是什么类型的
	//调用函数时的参数是a,不是*a,也不是&a
	//所以&a传的这个a是一个int类型，而*a的这个a就是指针，地址，所以要取地址传给它
	//虽然我语文不好，但是都讲到这份上了那应该是可以理解了
	return 0;
}

防止无意中被修改。
使用const参数可以兼容非const传参。

//代码太长，放段伪代码吧
struct Str	//不知道什么是结构体不急，稍后就会有
{
};

Str& test(Str &a,const Str &b)	
{
	//从b中取值，对a进行填充
	return a;//其实可以做void类型，没必要多此一举
}

int main()
{
	Str a,b,c;
	//b是有初值的，这是伪代码
	c = test(a,b);
	return 0;
}

Str& test(const Str &d)
{
	Str &e;
	···
	return e;
}

程序员能够修改调用函数中的数据对象。
通过传递引用而不是整个数据对象，可以提高程序的运行速度。

int age = 20; const int * pt = &age;
//该声明指出，pt指向一个const int，因此不能使用pt来修改这个值。
//现在来看一个很微妙的问题：其实age并不是一个常量，只是对于pt来说，它是一个常量。
//就是说age可以改，只不过不能用pt来改而已。

const int age = 20; int * pt = &age;

int sloth = 80; int * const finger = &sloth;
// 这种声明格式使得这个指针只能指向sloth,不过可以通过这个指针修改sloth的值。

void test(char *rc)
{
	···
	memset(rc,字符串);
	···
}

void test2(const JieGouTi1 *a,JieGouTi2 *b)
{
	//将a中的某些值赋值给b
}
//这里有一个注意点，传进去赋值的结构体指针最好用const.

自定义排序/搜索

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

回调

class B {
	char* b;
public:
	B() {
		b = new char[5];
		strcpy(b,"aaaa");
	}
	char* get_b() { return b; }
};

class A {
private:
	char* a;
public:
	A(B* temp) { a = temp->get_b(); };

	void set_A() { 
		strcpy(a, "kkkk");	//顶替掉了
	}
};

int main() {
	B* b = new B();
	A* a = new A(b);
	a->set_A();
	cout << b->get_b() << endl;

	return 0;
}

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++;	
	}	
}

struct tag {	// 定义一个结构体，名字叫tag 
    member-list	// 结构体成员变量
    member-list 
    member-list  
    ...
} variable-list ;	// 结构体的简称

variable-list vl;
variable-list *vl2;

struct tag t;
struct tag *t2;

//就是要带上‘struct’

#include <stdio.h>	//初学者，C语言开手
#include <conio.h>
#include <stdlib.h>
#include <memory.h>
#include <assert.h>

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

//如果不多来一个数据域，怎么能体现出通用链表的优势
typedef struct reported
{
	int amount;//交易金额
	int rflag; //交易方式	1、存款 2、取款 3、转账转出 4、转账转入
	int lastmoney;//余额
	int lastmoney2;//收款者的余额
	int number1;//付款账户
	int number2;//入款账户
	char time[12];//操作时间	
} REPORT_T;

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

POINT_T * head ;
extern POINT_T * head;

//创建结点
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++;		
	}
}