NDK探究之旅《七》—函数指针,宏定义的优缺点及应用场景

最新推荐文章于 2024-07-10 07:08:21 发布

androidstarjack

最新推荐文章于 2024-07-10 07:08:21 发布

阅读量2k

点赞数

分类专栏： JNI C C++ JNI和ndk android-jni 文章标签：内存数据指针宏定义

本文链接：https://blog.csdn.net/androidstarjack/article/details/72455218

版权

JNI 同时被 3 个专栏收录

13 篇文章 0 订阅

订阅专栏

JNI和ndk

11 篇文章 0 订阅

订阅专栏

10 篇文章 0 订阅

订阅专栏

指针：

概念

 在上一环节中我们都知道，指针： 就是一块内存地址

 在计算中所有的数据都必须放到内存之中。如：
 int i = 2 
 这行简单的代码可以这样理解：
    申请一块内存空间，大小为4个byte
    这块内存空间的变量别名为i
    用于存放int类型的数据

int 占用4个字节，char 占用1个字节。为了正确地访问这些数据，必须为每个字节都编上号码，就像门牌号、身份证号一样，每个字节的编号是唯一的，根据编号可以准确地找到某个字节。

指针作用：

指向这个变量或数组的首地址，是变量的间接引用方式。

其值如果改变，变量的值或数组元素的值也会跟着改变。

程序对变量的操作实际上是对变量所在的存储空间读取和写入数据。方便对变量的操作。

实例说明

int a=3;/*定义一个整型变量a，并赋初值3*/
int *p;/*定义一个指针变量P*/
p=&a;/*让p指向a的首地址，也就是a的地址*/  

程序为a分配一个2个字节的存储单元，假如2个字节的地址分别为（ABCD1和ABCD2，唯一）

那么p里面放的值就是ABCD1，不是3。这时可通过p直接引用a， 实际上*p=3。

以后不管a存放在内存中的哪个地方，只用通过调用p就可以引用a。

这时如果令*p=4，则最后的a值也为4。对于数组，指针是指向数组的首地址。

宏定义

定义：

就是把一段长代码（字符串）define定义成一个短的关键词，
以后下面程序要多次用到那段长代码的时候，直接用关键词代替，减少代码量

C++提供的预处理功能除了宏定义之外，
还有以下两个:   
   文件包含（#include命令）   
   条件编译（#ifdef …. #def …. #endif命令）

作用：

出错维护的时候也只要在define的时候，把define后的字符串修改，全文的关键词也就变量，方便维护

带参宏定义的一般形式为：

#define 宏名(形参列表) 字符串

带参宏调用的一般形式为：

宏名(实参列表);

如：

#define M(y) y*y+3*y  //宏定义
k=M(5);  //宏调用
在宏调用时，用实参5去代替形参y，经预处理宏展开后的语句为k=5*5+3*5。
#include<stdio.h> 
#define compete(x,y)(x*y) 
main(){
   int result, i = 5,j=6;
   result = compete(i,j); 
   printf("result=%d\n",result);
   system("pause"); 
}       
其输出结果为：30

*宏定义的优点*

方便程序的修改

使用简单宏定义可用宏代替一个在程序中经常使用的常量，这样在将该常量改变时，不用对整个程序进行修改，只修改宏定义的字符串即可，而且当常量比较长时，我们可以用较短的有意义的标识符来写程序，这样更方便一些。
提高程序的运行效率

使用带参数的宏定义可完成函数调用的功能，又能减少系统开销，提高运行效率。正如C语言中所讲，函数的使用可以使程序更加模块化，便于组织，而且可重复利用，但在发生函数调用时，需要保留调用函数的现场，以便子函数执行结束后能返回继续执行

*宏定义的缺点*：

由于是直接嵌入的，所以代码可能相对多一点
嵌套定义过多可能会影响程序的可读性，而且很容易出错；
对带参的宏而言，由于是直接替换，并不会检查参数是否合法，存在安全隐患。
补充：预编译语句仅仅是简单的值代替，缺乏类型的检测机制。这样预处理语句就不能享受C++严格的类型检查的好处，从而可能成为引发一系列错误的隐患。

#define MUL(A,B) A*B
    而在使用的时候,这样的调用:
    int a=1,b=2,c=3,d=0;
    d=MUL(a+b,c)
    经过编译时候展开,就变成了
    d=a+b*c
    而不是我们所希望的
    d=(a+b)*c
    [解决办法]
    其解决办法也很简单,就是给每个分量,都加上括号,就可以避免此类问题
    即,在宏定义的时候,如此定义:
    #define MUL(A,B) ((A)*(B))
    引用《C陷进与缺陷》的一句话，对其进行总结：   宏并不是函数,宏并不是语句,宏并不是类型定义

特殊情况时候,加了括号也无法避免错误

在宏定义中出现++或—之类的操作符的时候,即使加括号,也无法避免其中的问题

[例子]

   #define MIN(A,B) ((A)<(B)?(A):(B))
    如果进行如此调用
    int a=1,b=3,min=0;
    min=MIN(a++,b);

    经过编译替换展开后,就成了
    max=((a++)< (b)?(a++):(b))
    计算出来的结果,就是
    min=3,而不是我们所要的min=1了.

宏定义和typedef

宏定义#define为预处理指令在编译处理时进行简单的替换，不作正确性检查，不关含义是否正确照样带入，只在编译已被展开的源程序时才会发现可能的错误并报错。
typedef为复杂的声明定义简单的别名。在自己的作用域内给一个已经存在的类型一个别名。

typedef四大用途:

　　在C/C++中，typedef常用来定义一个标示符及关键字的别名，它是语言编译过程的一部分，但它并不实际分配内存空间， typedef可以增强程序的可读性，以及标示符的灵活性，但“非直观性”。

用途一：

　　定义一种类型的别名，而不只是简单的宏替换。可以用作同时声明指针型的多个对象。如：char* pa,pb;//我们意图同时声明两个指向字符变量的指针，但语法上它只声明了一个指向字符变量的指针和一个字符变量；用typedef表示则可同时声明两个指向字符变量的指针：
```
Typedef  char*  PCHAR;
PCHAR  pa,pb;
//等同于Char  *pa,*pb;
```
使用typedef优点：在使用大量指针的地方，更省事更直观。　
用途二：

在旧版本C语言中，辅助使用struct。即形式为：struct 结构名对象名，如：

 Struct tagPOINT1 { 
    Int x; 
    Int y; 
}； 
struct tagPOINT1 p1;

在C++中，表示为：结构名对象名，即：
tagPOINT1 p1;
于是发明了：

Typedef struct tagPOINT 
{ 
Int x; 
Int y; 
}POINT； 
Point p1;//少写一个struct。

- 用途三：

用typedef来定义与平台无关的类型:

如：定义一个叫REAL的浮点类型，在目标平台上，让它表示最高精度的类型为：
Typedef long double REAL; 
在不支持long double的平台上，改为：  
Typedef double REAL; 
在连double都不支持的平台上，改为：  
Typedef float REAL;
在跨平台时，只要改下typedef本身就行，不用对其他源码修改。 
typedef是定义了一种类型的新别名，不是像#define一样简单的字符串替换。

用途四：　　

　　为复杂的声明定义一个新的简单的别名。

方法是：在原来的声明里逐步用别名替换一部分复杂声明，
如此循环，把带有变量名的部分留到最后替换，得到的就是原声明的最简化版。如：
原声明：

Int * (* a[5])(int , char*);

简化版：

Typedef int * (* pFun)(int , char*); 
pFun a[5];

原声明：

Void (* b[10])(void (*)( ));

简化版：

Typedef void (* pFunParam)( ); 
Typedef void (* pFunx)(pFunParam); 
pFunx b[10];

原声明：

double(* )( ) (* e)[9];

简化版：

Typedef double(* pFuny)( ); 
Typedef pFuny(* pFunParamy)[9]; 
pFunParamy e;

　　理解复杂的声明可用“右左法则”：从变量名看起，先往右，再往左，碰到一个圆括号就调转阅读的方向；括号内分析完就跳出括号，还是按先右后左的顺序，如此循环，直到整个声明分析完。
　　如：

int (*func)(int *p);

　　首先找变量名func，外面有一对圆括号，而且左边是一个* 号，这说明func是一个指针；然后跳出这个圆括号，先看右边，又遇到圆括号，这说明( * func)是一个函数，所以func是一个指向这类函数的指针，即函数指针，这类函数具有int*类型的形参，返回值类型是int.

Int (* func[5])(int *); 
func右边是一个[]运算符，说明func是具有5个元素的数组；func的左边有一个* ，
说明func的元素是指针(这里的* 是修饰数组func[5]的，
原因是[]运算符优先级比* 高，func先跟[]结合)。
跳出这个括号，看右边，又遇到圆括号，说明func数组的元素是函数类型的指针，
它指向的函数具有int * 类型的形参，返回值类型为int。

　　总结为2个模式：

　　Type (*)(…)函数指针

　　Type (*)[]数组指针

typedef陷阱：

陷阱一：

记住，typedef是定义了一种类型的新别名，不同于宏，它不是简单的字符串替换。比如：
先定义：
typedef char* PSTR;
然后：
int mystrcmp(const PSTR, const PSTR);
const PSTR实际上相当于const char*吗?不是的，它实际上相当于char* const。
原因在于const给予了整个指针本身以常量性，也就是形成了常量指针char* const。
简单来说，记住当const和typedef一起出现时，typedef不会是简单的字符串替换就行。

陷阱二：

typedef在语法上是一个存储类的关键字(如auto、extern、mutable、static、register等一样)，虽然它并不真正影响对象的存储特性，如：
typedef static int INT2; //不可行
编译将失败，会提示“指定了一个以上的存储类”。

#include <stdio.h>
#include <malloc.h>
typedef int myInt;
typedef  long myLong;
typedef  double myDouble;
typedef  float myFloat;
typedef short myShort;
typedef char myChar;
typedef signed mysigned;
#define MAX(a,b) (a>b) ? a : b
    main(){
       myInt i = 121;
       myLong l = 1134123545;
       myDouble d = 12123.123;
       myFloat f = 1212.1415926;
       myShort s = 123;
       myChar c = 'm';
       mysigned u = 112;

        printf("i=%d\n",i);
        printf("l=%ld\n",l);
        printf("d=%lf\n",d);
        printf("f=%f\n",f);
        printf("c=%c\n",c);
        printf("s=%hd\n",s);
        printf("u=%d\n",u);
         int x , y, max;
         printf("input two numbers: ");
         scanf("%d %d", &x, &y);
          max = MAX(x, y);
           printf("max=%d\n", max);
       system("pause");
    }