// ex1.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"

#include "stdio.h"

#include <stdlib.h>

#include <string.h>

#include <time.h>

//1. 括号优先()[]

//2. 其它符号

void p1()

{

    // 什么是指针? 是变量， 存放的是类型T的地址（指向类型T的地址）

    int i = 1;

    int *p = &i;

    printf("i[%d] store in %p;\np[%p] store in %p, and solve p=[%d]", i, &i, p, &p, *p);

}

void p2()

{

    // 指针运算？ 取类型T的地址；地址偏移；解地址

    int i = 1;

    int *pi = &i; // 取地址 （这里取出来的地址是一个常量， ***指针类型的常量--即常指针****）

    //0X0024F7E4; 就是这个地址

    //p = 0X0024F7E4; //这样赋值编译错误， 因为类型不同

    pi = (int *)0X0024F7E4; // 这样就OK了

    int **ppi = π   // 指向指针

}

void f3(int ia[100])

{

    // 数组作为函数参数， **转化为指针

    printf("\nsizeof(ia) in f3 is %d", sizeof(ia));

    ia++; // 所以可以++

}

void p3()

{

    // 指针与数组

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

    // ** 数组名

    // 1. 声明时，产生数组名与其信息， 分配各元素空间

    // 2. 表达式中， 数组名是常指针， 故不能a++; sizeof（数组名) = 数量 * sizeof(T)

    printf("sizeof ia = %d, %p , %p, %p", sizeof(ia), ia, &ia, *&ia);  // 数组是一个类型对象， (这里有系统隐含转换成地址)

    // 3.数组名引用元素， ia[3] = *(ia + 3); 常指针偏移解值

    printf("\na[3] = %d  or  %d ", ia[3], *(ia + 3)); // 表示ia 所指类型偏移加3

    // 4. 作为函数参数， **转化为指针

    f3(ia);

}

void p4()

{

    // 指向数组的指针

    int ia[100], *ip = ia; // 指针，指向首元素

    int matrix[50][100];  // matrix 是一个50元素数组； 元素类型是int [100];

    int(*im)[100];      // 指针类型变量， 指向元素类型int [100];

    im = matrix;         // 指针， 指向首元素

    printf("%p == %p; %p == %p", im, matrix, im + 1, matrix + 1);    // 数组是一个类型对象， (这里有系统隐含转换成地址)

    printf("\nsizeof(im) = %d, sizeof(matrix)=%d", sizeof(im), sizeof( matrix ));

}

void p5()

{

    // 数组， 元素为字符

    char cars[10];

    // 指针,  指向元素类型, 元素类型为char;

    char(*p);

    p = cars; // 指针， 指向首元素

   // 数组， 元素为指针

   char *cars1[10];

   // 指针,  指向元素类型, 元素类型为char*;

   char* (*p1);

   p1 = cars1;

   // 数组， 元素为char* [10]

   char *cars2[10][10];

   // 指针,  指向元素类型, 元素类型为char*;

   char* (*p2)[10];

   p2 = cars2;

}

void p6()

{

    // 指针， 指针向函数

    void(*f)();  // 指针f,指向一个函数， 函数的参数为空， 返回类型为void

    f = p5;   // 函数是一个类型对象， 这里系统隐式转换成了地址

    f = &p5;   // 这里显式取了函数的地址

    f = *&p5;   //

    f();  // 指针隐式转函数， 调用

    (*f)();// 指针显式转函数， 调用

    printf("%p\n", p5);

    printf("%p\n", &p5);

    printf("%p\n", *&**&***p5); // 指针函数隐转了；要爆了！！！

    // 函数声明，f6, 返回指针类型; 仅声明

    char* f6();

    // 函数声明， f61, 参数(int), 返回一个指针；这个指针， 指向函数，该函数参数为(double*, char) ，返回值int

    int (*f61(int))(double*, char);

}

int _tmain(int argc, _TCHAR* argv[])

{

    p4();

}