一、C语言指针学习架构
1.基本数据类型---指针
2.字符串---指针
3.数组---指针
4.函数---指针
5.结构体---指针
6.共用体---指针
7.枚举---指针
8.位域---指针
9,常量---指针
10.变量---指针
二、C语言中的void与NULL
//void真正发挥的作用在于：
//（1） 对函数返回的限定；
//（2） 对函数参数的限定
// (3)void不能代表一个真实的变量, 凡是试图用它去表示真值得做法都是不合法的
//void的出现只是为了一种抽象的需要，如果你正确地理解了面向对象中“抽象基类”的概念，也很容易理解void数据类型。
//正如不能给抽象基类定义一个实例，我们也不能定义一个void（让我们类比的称void为“抽象数据类型”）变量。
#include<stdio.h>
#include<string.h>
#define ARRSIZE 87
int main()
{
int a = 8;
void *pVoid = a; //定义一个void变量没有意义
int *pInt;
pVoid = pInt; //void *可以指向任何类型的数据,“无类型”可以包容“有类型”
//pInt = pVoid, xxx,而“有类型”则不能包容“无类型”
//如果函数的参数可以是任意类型指针，那么应声明其参数为void *
//典型的如内存操作函数memcpy和memset的函数原型分别为：
//void * memcpy(void *dest, const void *src, size_tlen);
//void * memset ( void * buffer, int c, size_t num );
//这样，任何类型的指针都可以传入memcpy和memset中,memcpy和memset函数返回的也是void *类型.这也真实地体现了内存操作函数的意义
//因为它操作的对象仅仅是一片内存，而不论这片内存是什么类型,这样的memcpy和memset明显不是一个“纯粹的，脱离低级趣味的全能的”函数！
int intArray1[ARRSIZE] = {1, 2, 3};
int intArray2[ARRSIZE] = {4, 5, 6};
memset(intArray1, 0, ARRSIZE*sizeof(int));
printf("intArray1[2] = %d\n", intArray1[2]);
memcpy(intArray2, intArray1, ARRSIZE*sizeof(int));
printf("intArra2[2] = %d\n", intArray2[2]);
float intArray3[ARRSIZE] = {1,23, 2,64, 3,89};
float intArray4[ARRSIZE] = {4.3, 5.7, 6.9};
memset(intArray3, 0, ARRSIZE*sizeof(int));
printf("intArray3[2] = %f\n", intArray3[2]);
memcpy(intArray4, intArray3, ARRSIZE*sizeof(int));
printf("intArray4[2] = %f\n", intArray4[2]);
//对于指针如果暂时没有合适的初始化值，就应该把它置为NULL（0）。
int *p = NULL;
printf("&p = %p\n", &p); //逻辑地址为0x00000000，不可访问，会出现段错误，只适用于指针初始化未能赋值时使用。
printf("pVoid = %d, &pVoid = %p; pInt = %d, &pInt = %p\n", pVoid, &pVoid, pInt, &pInt);
(char *)pVoid++; //ANSI, GNU,ALL RIGHT!
printf("pVoid = %d, &pVoid = %p; pInt = %d, &pInt = %p\n", pVoid, &pVoid, pInt, &pInt);
return 0;
}
#include<stdio.h>
int main()
{
int *p = NULL;
printf("&p = %p\n", &p); //输出地址是随机的
return 0;
}
三、C语言常量大全
//--常量--const--只读--：数值不发生改变的数据
//常量最多有3个属性--代号/地址/本身值
#include<stdio.h>
int main()
{
//一、字符常量
'r'
'5'
' '
'\n'
'\0'
'\777' //1~3位八进制
'\xef' //1~2位十六进制
//二、整型常量
10
//三、浮点型常量
3.14
//四、枚举常量
enum WEEKDAY
{
MON = 1,
TUE,
WED,
THU,
FRI,
STA,
SUN
};
//五、常量与指针
//1,指针常量
int a = 1;
int *const b = &a;
//const 修饰 b, b-->只读,但*b未被修饰故可读可写.
//const位于*右侧，表明对象是常量，内容为指针(地址)
//声明常量b，它的值是变量a的地址
*b = 20;
printf("b = %p, *b = %d\n", b, *b);
//2,常量指针
int c = 39;
const int *d = &c;
// const 修饰的是*d,*d-->只读,但d未被修饰故可读可写
d = b;
printf("d = %p, *d = %d\n", d, *d);
//int strcmp(const char *str1, const char *str2);
//因为函数的参数声明用了常量指针的形式，就保证了在函数内部，
//那个常量不被更改。
//也就是说，对str1和str2的内容更改的操作在函数内部是不被允许的
//但是可以对他们的地址进行操作（间接的对他们进行（整体的操作））
//3,指针常量的指针常量
const int * const e = &a; //此时e或者*e均为常量，e,*e-->只读
//六、常量与字符串（字符数组）
char* ptr1 = "abc"; //"abc" 是常量
//因为定义的是一个普通指针，并没有定义空间来存放"abc"，
//所以编译器得帮我们找地方来放"abc"，
//显然，把这里的"abc"当成常量并把它放到程序的常量区是编译器最合适的选择 //所以尽管ptr的类型不是const char*，
//并且ptr[0] = 'x';也能编译通过，
//!!!但是执行ptr[0] = 'x';就会发生运行时异常，
//因为这个语句试图去修改程序常量区中的东西。
//这种写法原来在c++标准中是不允许的，
//但是因为这种写法在c中实在是太多了，
//为了兼容c，不允许也得允许。虽然允许，
//但是建议的写法应该是
const char* ptr = "abc";
//这样如果后面写ptr[0] = 'x'的话编译器就不会让它编译通过，
//也就避免了上面说的运行时异常。
//如果char* ptr = "abc";写在函数体内，那么虽然这里的"abc\0"被
//放在常量区中，但是ptr本身只是一个普通的指针变量，
//所以ptr是被放在栈上的, 只不过是它所指向的东西被放在常量区罢了
//字符串常量的类型可以理解为相应字符常量数组的类型，
// 如"abcdef"的类型就可以看成是const char[7]""
char *str = "This is a special string";
char string[ ]="This is a string";
//字符指针str与字符数组string的区别是：
//str是变量,可改变str使它指向不同的字符串,但不能改变str所指的字符串常量
//string是一个数组，可以改变数组中保存的内容。
//字符串本身就可以代表他们的地址
//七、字符数组与函数数组传参
char str[] = "abcdef"; //就有sizeof(str) == 7,因为str的类型是char[7]，
sizeof("abcdef") == 7; //因为"abcdef"的类型是const char[7]。
char *ptr = "abcdef"; //就有sizeof(ptr) == 4，因为ptr的类型是char*。
char str2[10] = "abcdef"; //就有sizeof(str2) == 10,str2的类型是char[10]
void func(char sa[100],int ia[20],char *p)
// 就有sizeof(sa) == sizeof(ia) == sizeof(p) == 4;
// 因为sa的类型是char*，ia的类型是int*，p的类型是char*
return 0;
}
---------------------
四、C语言变量总结
//--变量--可写--：数值可发生改变可被覆盖
//变量一般有4个属性：可写/代号/地址/本身值
#include<stdio.h>
int main()
{
//一、字符，整型，浮点型变量
char a = 'a';
int b = 3;
float c = 3.141592653;
//二、指针变量
//三、数组变量
//四、结构体变量
//五、函数变量
return 0;
}
---------------------