C语言指针

#include <stdio.h>

int main()
{
	int * p; // int *是指针类型，p是对应的变量，定义的指针变量p只能用来存储int类型变量的地址
	int i = 3, j;
	
	p = &i; // 指针变量只能用来存储对应类型变量的地址，所以这里需要对变量i进行取地址操作，即&i
	/*
		指针变量p保存了变量i的地址，这样的话，我们称：p指向i。通俗地说，通过p可以找到i
		虽然p指向i，但变量p和变量i不是同一个变量
		更准确地说，修改其中任何一个变量p值不会影响变量i，反之同理
	*/
	
	printf("%d %d\n", *p, i);
	/*
		如果一个指针变量指向某个普通变量，则在指针变量前加上*后就完全等同于指向的普通变量
		换句话说，可以通过指针变量前加*来找到那个指向的普通变量
		以本程序为例，这里的*p就是以p的内容为地址的变量
	*/

	j = *p; // *p就是i，所以相当于将i的值赋给了j
	printf("i = %d, j = %d\n", i, j); // 输出结果为i = 3, j = 3

	return 0;
}

#include <stdio.h>

int main()
{
	int * p;
	int i = 5;
	
	*p = i; // 出错行
	printf("%d\n", *p);

	return 0;
}

#include <stdio.h>

int main()
{
	int * p;
	int * q;
	int i = 5;
	
	p = &i;
	
	*q = p; // 出错行
	printf("%d\n", *q);

	return 0;
}

#include <stdio.h>

void f(int i)
{
	i = 99;
}

int main()
{
	int i = 66
	printf("%d\n", i);
	
	f(i);
	printf("%d\n", i);

	return 0;
}

#include <stdio.h>

void f(int * p) // 通过接收地址来确定要修改的变量
{
	*p = 99; // *p就是以p变量的内容为地址的变量，也就是要通过该函数修改的变量
}

int main()
{
	int i = 66
	printf("%d\n", i); // 输出结果为66
	
	f(&i); // 由于函数f的形参是指针变量，故需将变量i的地址发送过去
	printf("%d\n", i); // 输出结果为99

	return 0;
}

void swap(int a, int b)
{
	int t;
	
	t = a;
	a = b;
	b = t;
}

int main()
{	
	int a = 3, b = 5;
	
	swap(a, b);
	
	printf("a = %d, b = %d\n", a, b);

	return 0;
}

void swap(int * p, int * q)
{
	int t;
	
	t = *p;
	*p = *q;
	*q = t;
}

int main()
{	
	int a = 3, b = 5;
	
	swap(&a, &b);
	
	printf("a = %d, b = %d\n", a, b);

	return 0;
}

#include <stdio.h>

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

	t = p;
	p = q;
	q = t;
}

int main()
{	
	int a = 3, b = 5;
	
	swap(&a, &b);
	
	printf("a = %d, b = %d\n", a, b);

	return 0;
}

#include <stdio.h>

int main()
{
	int a[5];
	int b[5];
	
	a = b; // 错误，因为a和b都是常量，所以无法进行赋值操作
	a = &a[2]; // 错误，因为a是常量，无法对一个常量进行赋值操作
	
	return 0;
}

#include <stdio.h>

int main()
{
	int a[5];

	printf("%#X", &a[0]);
	printf("%#X", a); // 与上一行输出结果相同，因为一维数组名就是数一维组中第一个元素的地址

	return 0;
}

#include <stdio.h>

int main()
{
	int a[5];
	int i;
	
	for (i = 0; i < 5; i++) // 向一维数组中读入元素
		scanf("%d", &a[i]); // 通过下标引用数组中的元素

	for (i = 0; i < 5; i++) // 输出一维数组的内容
		printf("%d ", *(a + i)); // 通过指针引用数组中的元素

	return 0;
}

#include <stdio.h>

int main()
{
	int a[5];
	int * p = &a[1];
	int * q = &a[4];

	printf("%d\n", q - p); // 输出结果为3，证明相隔3个元素

	return 0;
}

#include <stdio.h>

// 自定义的print函数，其功能是将一维数组输出
void print(int a[], int length)
{
	int i;

	for (i = 0; i < length; i++)
		printf("%d ", a[i]); // 也可以写成printf("%d ", *(a+i));
	
	printf("\n");
}

int main()
{
	int a[5] = { 1, 2, 3, 4, 5 };
	int b[6] = { -1, -2, -3, -4, -5, -6 };
	int c[100] = { 23, 88, 99, 44 };

	print(a, 5);
	print(b, 6);
	print(c, 100);

	return 0;
}

#include <stdio.h>

int main()
{
	char c = 'A';
	int i = 99;
	double x = 66.66;

	char * p = &ch;
	int * q = &i;
	double r = &x;

	printf("%d %d %d\n", sizeof(c), sizeof(i), sizeof(x)); // 输出结果为1 4 8
	printf("%d %d %d\n", sizeof(p), sizeof(q), sizeof(r)); // 输出结果均为4

	return 0;
}

#include <stdio.h>
#include <malloc.h>

int main()
{
	int i; // 静态分配了4个字节的存储空间

	int* p = (int*)malloc(4);
	/*
		1.要使用malloc函数，需添加malloc.h头文件
		2.malloc函数只有一个形参，其类型为整型
		3.实参中的4表示请求操作系统为本程序分配4个字节的动态存储空间
		4.malloc的返回值是分配给该系程序的第一个字节的地址
		5.由于第一个字节的地址不能确定具体的变量类型，所以需要强制类型转换
		6.第7行代码一共分配了8个字节的存储空间，其中变量p占4个字节，p指向的空间也占是4个字节
		7.变量p所占的内存是静态分配的，p所指向的内存是动态分配的
	*/

	free(p); 
	/*
		free(p)表示释放p所指向的内存
		free函数只能用来释放动态内存，不能用来释放静态内存，静态内存只能由操作系统自动释放
		free(p)只是释放了p对应的内存空间，但p的内容依旧存在
	*/

	return 0;
}

#include <stdio.h>
#include <malloc.h>

int main()
{
	int a[10]; // 静态构造一维数组
	int length;
	int* pArray;
	int i;
	
	scanf("%d", &length);

	pArray = (int*)malloc(sizeof(int) * length);
	/*
		动态构造一维数组
		该动态数组数组名为pArray，数组长度为length，数组中每个元素都是int类型
	*/

	// 对该动态一维数组手动赋值
	for (i = 0; i < length; i++)
		scanf("%d", &pArray[i]);

	// 输出该动态一维数组的内容
	for (i = 0; i < length; i++)
		printf("%d ", *(pArray + i));
	
	printf("\n");

	free(pArray); // 释放该动态数组

	return 0;
}

#include <stdio.h>

int main()
{
	int i = 10;
	int * p = &i;
	int ** q = &p;
	int *** r = &q;
	
	r = &p; // 错误，因为r是int *** 类型，它只能用来存储int ** 类型变量的地址
	
	printf("i = %d\n", ***r);

	return 0;
}

#include <stdio.h>

void g(int ** q) // 由于p的类型是int *，所以q的类型必须是int **，因为q要用来存放p的地址
{
	
}

void f()
{
	int i;
	int * p;
	
	p = &i;
	
	g(&p); // 要通过g函数修改p的内容，则必须发送p变量的地址
}

int main()
{
	f();

	return 0;
}

#include <stdio.h>

void f(int** q)
{
	int i = 5;

	*q = &i; // 由于q储存了p的地址，所以*q就是p，这行代码实质是将i的地址赋给了p
}

int main()
{
	int* p;

	f(&p);

	printf("i = %d\n", *p); // 由于p储存了i的地址，所以*p就是i

	return 0;
}

#include <stdio.h>

void f(int** q)
{
	*q = (int*)malloc(sizeof(int));
	
	**q = 5;
}

int main()
{
	int* p;

	f(&p);

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

	return 0;
}

#include <stdio.h>

void fun(int * p)
{
	int s;
	p = &s;
}

int main()
{
	int * p;

	fun(p);

	return 0;
}

#include <stdio.h>

void fun(int ** p)
{
	int s;
	*p = &s;
}

int main()
{
	int * p;

	fun(&p);

	return 0;
}

#include <stdio.h>
#include <malloc.h>

void fun(int * p)
{
	p = (int *)malloc(sizeof(int));
}

int main()
{
	int * p;

	fun(p);

	return 0;
}

#include <stdio.h>
#include <malloc.h>

void fun(int ** p)
{
	*p = (int *)malloc(4);
}

int main()
{
	int * p;

	fun(&p);

	return 0;
}