二级指针、函数指针、枚举、static、const

最新推荐文章于 2022-12-08 00:30:34 发布

forrhuen

最新推荐文章于 2022-12-08 00:30:34 发布

阅读量329

点赞数

本文链接：https://blog.csdn.net/forrhuen/article/details/37822325

版权

1.函数指针：即指向函数类型的指针，用于回调。

函数名，就是函数的地址。

语法：返回类型 (*指针名)(参数列表);

例：int (*fun)(int,int);(声明)

fun = 函数名;（实现）

fun(,);(调用)

2.指针的指针:即地址的地址(二级指针)

3.宏。简单的替换作用

4.typeef:重新定义类型的新名字

5.枚举:实质是整型。

常用于与switch匹配，当一个变量只有几种可能，就可以定义枚举，优化可读性。

6.static在程序加载时就分配内存。

静态区:存储静态变量，程序运行过程中变量一直存在，程序关闭变量才被系统回收。作用：记录某值的状态。

栈区:存函数体内的局部变量，变量使用后系统自动释放。效率高，空间有限。

堆区:存malloc、对象。手动释放。

局部static与全局（外部）static区别:局部变量只是在局部使用，其作用域不一样。

外部extern用于：1.声明外部函数2.外部文件中声明外部变量。Extern和static共同点：具有共享变量特点。不同点，extern的作用域是最广的，作用于整个程序。

寄存器Register常用于声明循环控制变量，提高运算速度。

7.const用于修饰不允许改变的变量。

与#define区别:const是运行时内存实际存储；#define在编译期进行处理。

*前*后const.

关于const:http://www.cnblogs.com/icemoon1987/p/3320326.html

#define MAX1(A,B) A>B?A:B

static int i = 0;  

int getSum(int a,int b);
int getSum(int a,int b)
{
    int result = a + b;
    return result;
}

void getSum2(int a);
void getSum2(int a)
{
    printf("%d\n",a);
}

enum weekday{
    Monday = 0,
    Tuesday,
    Wednesday,
    Thursday,
    Friday
};

int fun1()
{
    i++;
    printf("i = %d\n",i);
    
    static int s = 1;
    s++;
    printf("static s = %d\n",s);
    int a = 0;
    int c = a +1;
    return c;
    
    
};


int main(int argc, const char * argv[])
{
    /*
//      二级指针
//    int a =10;
//    int *p = &a;
//    int *m = &p;   //出错
//    printf("a = %d",*m);
    
    int a =10;
    int *p = &a;
    int **m;
    m = &p;
    printf("a = %d,*p = %d\n",**m,*p);

    char * str[3] = {"iphone","android","hello"};
    char *p1 = str;
    char **m1 = &p1;
    printf("%s\n",**m1);
    */
    /*
    //函数指针
    int (*fun)(int,int);    //定义一个函数指针

    fun = getSum;           //fun = getSum2;出错，参数个数不对应
    
    
    int c = 0;
    c = fun(3,4);//c = (*fun)(3,4);
    
    
    printf("c = %d\n",c);
    //hong
    int d = MAX1(3,5);
    printf("max = %d\n",d);
    //枚举
    enum weekday m = 0;//或者enum weekday m = Monday;
    m = 1;
    m++;
    switch (m) {
        case Monday:
        {
            
            printf("上课");
            break;
        }
        case Tuesday:
        {
            
            printf("还是上课");
            break;
        }
        case Wednesday:
        {
            
            printf("上机");
            break;
        }
        default:
            break;
    }*/
    //static
    fun1();
    fun1();
    
    //const1
    int x = 10,y = 11;
    const int *t = &x;
    t = &y;
    //*t = 20;出错。指针可以改变，但是不能通过此指针改变所指的数值。只读作用（做参数时可以防止返回多个值）
    
    //2
    int * const r = &x;
    //r = &x;出错。指针不能改变，但是指针所指向的内容能通过此指针改变。
    *r = 20;
    
    printf("%d,%d\n",*t,*r);
    
    return 0;
}

1ex

给定char*str[3] = {"ios","ipod","ipad"};将每个字符串中的i去掉并保存到数组中。然后输出字符串数组str

int main(int argc, const char * argv[])
{

    char a[] = "ios";
    char b[] = "ipod";
    char c[] = "ipad";
    
    char * str[3] = {a,b,c};
    char **p = str;
    for (int i = 0; i < 3; i++)
    {
        printf("*p = %s\n",*p);
        char *m = *p;
        char *n = m + 1;
        while (*m != '\0')
        {
            printf("*m = %c\t *n = %c\n",*m,*n);
            *m = *n;
            
            m++;
            n++;
        }
        p++;
    }
    
    p = str;
    for (int i = 0; i < 3; i++) {
        printf("%s\n",*p);
        p++;
    }
    return 0;
}

2ex

enum month
{
    Jan = 1,
    Feb,
    Mar,
    Apr,
    May,
    Jun,
    Jul,
    Aug,
    Sep,
    Oct,
    Nov,
    Dec
};

struct date
{
    enum month m;
    int y;
    int d;
};

int main(int argc,const char * argv[])
{
      //2设计含有枚举数据的结构体类型来描述日期，其中，月（m）为枚举类型，年（y）、日（d）为整型。
    //编程实现：输入一个英国方式(2nd March, 1996)表示的日期，输出国际标准方式的日期(JUN.5TH,2002

    struct date time;
    printf("请输入一个年份\n");
    scanf("%d",&time.y);
    printf("请输入一个日期\n");
    scanf("%d",&time.d);
    printf("请输入一个月份\n");
    scanf("%d",&time.m);

    printf("%d,%d,%d",time.m,time.d,time.y);
   return 0;       
}

文字常量区:http://blog.163.com/liyani_1980/blog/static/38604145201121124347692/

#include <stdio.h>
#define SHAO (120+50)
#define MAX(X,Y) X>Y?X:Y

enum WeekDay {
    Monday = 0,
    Tuesday,
    WesDay,
    ThusDay,
    Friday,
    SixDay,
    Sunday
    };

enum SinaCellType {
    mainContentType = 0,
    sixinContenType 
    };
void function(char *str[],int len);
void function(char *str[],int len){
    

}

int getMax(int a,int b);
int getMax(int a,int b){
    
    return a>b?a:b;
}

int *pointerGetMax(int a,int b);
int *pointerGetMax(int a,int b){
    
    int *pMax = NULL;
    int max = a>b?a:b;
    pMax = &max;
    return pMax;
    
}

int *getAnArray();
int *getAnArray(){
    
    static int array[5] = {1,2,3,4,5};
    return array;
}

void printNumberOfCount();
void printNumberOfCount(){
    static int count = 0;
    count++;
    printf("count = %d",count);
}
int main(int argc, const char * argv[])
{
    /*
    //________指针的指针__________
    int a = 10;
    int *p = &a;
    int **m = &p;
    int ***n = &m;
    printf("%d\n",***n);
    printf("%d\n",**m);
    printf("%d\n",*p);
    
    //________函数指针____________
    //应用在OC中block块底层编程中
    int x = 10;
    int y = 15;
    int max = getMax(x, y);
    
    int *pMax = pointerGetMax(x, y);
    
    int p2Max = *(pointerGetMax(x, y));
    printf("max = %d *pMax = %d p2Max = %d",max,*pMax,p2Max);
    printf("\n");
    
    // static
    int *pointer = getAnArray();
    
    for (int i = 0; i < 5; i++) {
        printf("%d",*(pointer+i));
    }
     */
    /*    static
     程序分为静态区、堆区、栈区
     栈区：栈区存储的是程序函数里的变量，当函数体运行完了之后，该变量销毁（这块不需要我们手动管理内存）
     静态区：静态区存储的时静态变量，静态变量是在程序退出后，由系统自动销毁，在程序运行过程中一直存在（这块不需要我们手动管理内存）静态变量的声明，我们用static关键字，如:static int a = 10;其中a将会一直存在程序的运行过程中，不会被销毁，直到程序退出
     堆区：堆区是我们手动申请内存的地方，我们手动申请内存存储的变量都是存放于此，我们没有将该块内存返还给系统，该块内存将会一直占用程序的内存，直到程序退出，所以这块内存我们需要手动管理
     
     
     */
    for (int i = 0; i< 3; i++) {
        printNumberOfCount();
    }
    printf("\n");
    
    //________const________
    const int shaoqingan = 10;
//    shaoqingan = 5;
   
    //________define____
    /*
     它是提示编译器预编译，它是完全将表达式用一个简单字符文字代替而没有任何运算意义
     */
    int li = SHAO * 100;
//    120+50*100
    li = MAX(12,15);
    printf("li = %d",li);

    enum WeekDay day = ThusDay;
    
    switch (day) {
        case Monday:
            printf("yi");
            break;
        case Tuesday:
            printf("er");
            break;
        case 2:
            printf("san");
            break;
        case 3:
            printf("si");
            break;
        case 4:
            printf("wu");
            break;
        case 5:
            printf("liu");
            break;
        case 6:
            printf("qi");
            break;
        default:
            break;
    }
    
    return 0;
}