#include <iostream>

using namespace std;

int main(void)

{

	printf("%d\n", 1);

	int i = -6;

	//while 一般而言，所有非零值都视为真，只有 0 被视为假

	while (i) 

	{

		printf("%d\n", i);

		i++;

	}

	return 0;

}

/*

	关于 const 与指针之间的运用问题

*/

#include <iostream>

using namespace std;

int main(void)

{

	int a = 6;

	int i = 1;

	// *p 常量化

	const int* p = &a;

	cout << "a: " << *p <<endl;		//6

	p = &i;

	cout << "p = &i : " << *p << endl;		//1

	//*p = 10;  //*p 为 const 值不可改变

	cout << "*p: " << *p << endl;   // 

	// 对 a 的值进行修改，间接的修改 * p 的值

	a = 7;

    p = &a;

	// 通过对 a 值的修改，间接修改了 指向 p 地址的 p

	cout << "*p: " << *p << endl;   // 7

	int b = 8;

	//*p 固定值不能改变，但是 p 的地址可以改变

	p = &b;  // 通过赋值新的地址 p

	cout << "*p: " << *p << endl;

	//t 地址常量

	int* const T = &a;   

	cout << "const p: " << *T << endl; // 值为 7

	// T = &b;  // 地址为 cosnt 常量，不可进行修改

	// 当忍让可以通过修改 a 的值，间接修改引了 a 地址的 T

	a = 9;

	cout << "const p: " << *T << endl;

	// 地址和值都是常量

	const int* const S = &a; // 初始化为 a 的 9 值

	// S = &b;  // 地址值不再允许改变

	// 通过 a 的值可以 改变 S 的值

	//

	a = 10; //a 仍然为变量，仍然可以进行改变

	cout << "const int* const S ：" << *S << endl;

	// 对 * S 以及 S 的地址，在初始化后不可再次改变

	return 0;

}

// 不加 * 代表真个字符串地址，加 * 对应地址的单个 字符

const char* a = "helloworld"; // 常量字符串

// 在没有取单独值时，就是指针移动，指针移动的是对应的字符对应的字节

cout << a + 1 << endl;        // 起始地址右移，变为 elloworld

char b[] = "morning";  

cout << b+1 << endl;          // 同样地址右移，变为 orning

// 其相等，取地址位置的一个字符

cout << *(a + 1) << endl;   // 取固定值

cout << b[1] << endl;;

printf("%c\n", *(a + 1));

printf("%c\n", b[1]);

void getMemory(char** n)

{

	*n = (char*)malloc(100);

}

char* n = NULL;

getMemory(&n);

strcpy(n, "nihaohaohao");

cout << n << endl;

int func(char s[5])

{

	cout << endl;

	return 1;

}

sizeof(func("1234"));  // 得出返回值类型 int 的大小，4 个字节

#include <stdio.h>

int main(void)

{

	short num = 20;

	int a = 1;

	printf("%d\n", sizeof(num = a+5));

	printf("%d\n", num);

	return 0;

}

#include<stdio.h>

int main()

{

    int a[5] = { 1, 2, 3, 4, 5 };

 	//a 为数组 a [0] 的地址与数组 a 地址重合，&a 取的就是数组 a 的地址

    int* ptr = (int*)(&a + 1);    // 取了数组 a 之后的地址空间

    printf("%d,%d", *(a + 1), *(ptr - 1)); //a 的地址空间减去一个 sizeof (int) 得出结果: 2,5

    return 0;

}

#include<stdio.h>

// 此结构体的大小是 20 个字节

struct Test

{

	int Num;

	char* pcName;

	short sDate;

	char cha[2];

	short sBa[4];

}*p;

int main()

{

	p = (struct Test*)0x100000;// 假设 p 的值为 0x100000。  //p 的地址 0x0000000000100000

	//% p 输出地址

	//p 为结构体类型，每次指针移动一位，就是移动的 strct Test 的大小，和数组移动时一样

	// 移动了一位，就是内存地址移动了 20 个字节

	printf("%p\n", p + 0x1);   //0x100020

	// 使用了类型转换，无符号长整型 对应的是值 +1

	printf("%p\n", (unsigned long)p + 0x1); //0x100001

	// 使用无符号整型，那整型 + 1 就是 int, 对应的是指针类型，要加 4 个字节就是 4 个字节

	printf("%p\n", (unsigned int*)p + 0x1);  //0x100004

	return 0;

}

#include<stdio.h>

int main()

{

    int a[4] = { 1, 2, 3, 4 };

    int* ptr1 = (int*)(&a + 1); // 上通 4 &a 取的是整个数组 a 的地址，+1 即跳过一个 int (*)[4] 类型，然后再将它强制转换为 int * 类型

    // 首先计算出 a 在内存中的存储，使用小端存储结构，+1 之后

    int* ptr2 = (int*)((int)a + 1); 

    printf("%x,%x", ptr1[-1], *ptr2); //% x 以 16 进制打印

    return 0; 

}

#include<stdio.h>

int main()

{

    // (0, 1) 逗号运算符，取最后一个

    // { {1,3},{5,0},{0,0} }

    int a[3][2] = { (0, 1), (2, 3), (4, 5) };

    int* p;

    p = a[0];

    printf("%d", p[0]); //1

    return 0;

}

#include<stdio.h>

int main()

{

    int a[5][5];

    //p 是一个数组指针，指向一个有 4 个整型元素的数组

    int(*p)[4];  // 取对应的内存，指针画笔

    //a 是数组名，数组名代表的是数组首元素的地址，二维数组的首元素是第一行元素，

    p = a;

    //-4 取地址，以补码 16 进制的形式

    printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);

    return 0;

}

#include<stdio.h>

int main()

{

    int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

    int* ptr1 = (int*)(&aa + 1); // 取了数组 aa 之后的内存

    int* ptr2 = (int*)(*(aa + 1)); // 取的是 aa [1][0] 的地址

    printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1)); //10，5

    return 0;

}

#include<stdio.h>

int main()

{

	// 代表多个字符串 a [0],a [1],a [2]   char 变成了字符串

	const char* a[] = { "work","at","alibaba" };

	//a 的地址默认是 a [0] 的地址，

	const char** pa = a;

	pa++;   //a[1]

	printf("%s\n", *pa);  //at

	return 0;

}

#include <stdio.h>

int main()

{

	char* c[] = { "ENTER","NEW","POINT","FIRST" };

	char** cp[] = { c + 3,c + 2,c + 1,c };

	char*** cpp = cp;

	printf("%s\n", **++cpp);

	printf("%s\n", *-- * ++cpp + 3);

	printf("%s\n", *cpp[-2] + 3);

	printf("%s\n", cpp[-1][-1] + 1);

	return 0;

}