一、在一些宏处理中常有ifdef __cplusplus如下：
#ifdef __cplusplus
extern "C" {
#endif
//一段代码
//...
//...
#ifdef __cplusplus
}
#endif#ifdef __cplusplus
#define RH_EXTERN_C_BEGIN extern "C" {
#define RH_EXTERN_C_END }
#else
#define RH_EXTERN_C_BEGIN
#define RH_EXTERN_C_END
#endif
RH_EXTERN_C_BEGIN
...
...
RH_EXTERN_C_END__cplusplus是cpp中的自定义宏，那么定义了这个宏的话表示这是一段cpp的代码，也就是说，上面的代码的含义是:如果这是一段cpp的代码，那么加入"extern "C"{"和" }"处理其中的代码，其中{ }内部的代码是通过extern"C"进行处理。要明白为何使用extern"C"，还得从cpp中对函数的重载处理开始说起。在c++中，为了支持重载机制，在编译生成的汇编码中，要对函数的名字进行一些处理，加入比如函数的返回类型等等.而在C中，只是简单的函数名字而已，不会加入其他的信息.也就是说:C++和C对产生的函数名字的处理是不一样的.C++之父在设计C++之时，考虑到当时已经存在了大量的C代码，为了支持原来的C代码和已经写好C库，需要在C++中尽可能的支持C，而extern"C"就是其中的一个策略。因此，为了在C++代码中调用用C写成的库文件，就需要用extern"C"来告诉编译器:这是一个用C写成的库文件，请用C的方式来链接它们。这个{}里面的#endif对应上面的#ifdef-cplusplus，#ifdef-cplusplus对应最后的#endif, #ifdef与#endif总是一一对应的，表明条件编译开始和结束。
二、宏参数中有#,##
#define f(a,b) a##b
#define g(a) #a
#define h(a) g(a)
int RHmain()
{
printf("%s\n",h(f(1,2)));//12
printf("%s\n",g(f(1,2)));//f(1,2)
return 0;
}输入结果：
12
f(1,2)
#是把宏参数变为一个字符串，##是把两个宏参数连接在一起
在展开当前宏函数时，如果形参有#或##则不进行宏参数的展开，否则先展开宏参数，再展开当前宏。
首先看h(f(1,2)) h(a)没有#和##,则进行展开宏参数：h(12)->12
再看g(f(1,2)),g(a)有#,不进行宏参数的展开 :f(1,2)
三、有时在代码调试常用NSAssert，NSCAssert
NSAssert/NSCAssert 前者是适合于Objective-C的方法,_cmd和self与运行时有关.后者是适用于C的函数.
在SDK中的定义：
#if !defined(NS_BLOCK_ASSERTIONS)
#if !defined(_NSAssertBody)
#define NSAssert(condition, desc, ...) \
do { \
__PRAGMA_PUSH_NO_EXTRA_ARG_WARNINGS \
if (!(condition)) { \
[[NSAssertionHandler currentHandler] handleFailureInMethod:_cmd \
object:self file:[NSString stringWithUTF8String:__FILE__] \
lineNumber:__LINE__ description:(desc), ##__VA_ARGS__]; \
} \
__PRAGMA_POP_NO_EXTRA_ARG_WARNINGS \
} while(0)
#endif
#if !defined(_NSCAssertBody)
#define NSCAssert(condition, desc, ...) \
do { \
__PRAGMA_PUSH_NO_EXTRA_ARG_WARNINGS \
if (!(condition)) { \
[[NSAssertionHandler currentHandler] handleFailureInFunction:[NSString stringWithUTF8String:__PRETTY_FUNCTION__] \
file:[NSString stringWithUTF8String:__FILE__] \
lineNumber:__LINE__ description:(desc), ##__VA_ARGS__]; \
} \
__PRAGMA_POP_NO_EXTRA_ARG_WARNINGS \
} while(0)
#endifNSParameterAssert/NSCparameterAssert两者的区别也是前者适用于Objective-C的方法,后者适用于C的函数.NSAssert/NSCAssert和 NSParameterAssert/NSCparameterAssert的区别是前者是所有断言,后者只是针对参数是否存在的断言,所以可以先进行参数的断言,确认参数是正确的,再进行所有的断言,确认其他原因.
NSAssert的用法
int rh = 3;
NSAssert(rh == 5, @"rh must equal to 5");//第一个参数是条件,如果第一个参数不满足条件,就会记录和打印第二个参数//回记录并打印断言日志
Terminating app due to uncaught exception 'NSInternalInconsistencyException', reason:'rh must equal to 5
NSParameterAssert的用法
- (void)assertWithPara:(NSString *)str
{
NSParameterAssert(str); //只需要一个参数,如果参数存在程序继续运行,如果参数为空,则程序停止打印日志
//further code ...
}//如果str为空则有如下类似的日志
Terminatingappdue to uncaughtexception'NSInternalInconsistencyException',reason:'Invalid parameter not satisfying: str'
Xcode已经默认将release环境下的断言取消了,免除了忘记关闭断言造成的程序不稳定.
NSAssertionHandler:自定义处理方法,程序不会直接崩溃，NSAssertionHandler实例是自动创建的，用于处理错误断言。如果NSAssert和NSCAssert条件评估为错误，会向NSAssertionHandler实例发送一个表示错误的字符串。每个线程都有它自己的NSAssertionHandler实例。
自定义NSAssertionHandler的子类
@interface RHAssertHandler : NSAssertionHandler
@end#import "RHAssertHandler.h"
@implementation RHAssertHandler
//处理Objective-C的断言
- (void)handleFailureInMethod:(SEL)selector object:(id)object file:(NSString *)fileName lineNumber:(NSInteger)line description:(NSString *)format,...
{
NSLog(@"NSAssert Failure: Method %@ for object %@ in %@#%li", NSStringFromSelector(selector), object, fileName, (long)line);
}
//处理C的断言
- (void)handleFailureInFunction:(NSString *)functionName file:(NSString *)fileName lineNumber:(NSInteger)line description:(NSString *)format,...
{
NSLog(@"NSCAssert Failure: Function (%@) in %@#%li", functionName, fileName, (long)line);
}
@end
NSAssertionHandler *myHandler = [[RHAssertHandler alloc] init];
//给当前的线程
[[[NSThread currentThread] threadDictionary] setValue:myHandler
forKey:NSAssertionHandlerKey];实现这些以后,程序能够获得断言失败后的信息,但是程序有可能继续运行,不会强制退出程序.
也可以如下定义方便自己使用
#define RHAssertNil(condition, description, ...) NSAssert(!(condition), (description), ##__VA_ARGS__)
#define RHCAssertNil(condition, description, ...) NSCAssert(!(condition), (description), ##__VA_ARGS__)四、强弱引用的合成
#ifndef weakify
#if DEBUG
#if __has_feature(objc_arc)
#define weakify(object) autoreleasepool{} __weak __typeof__(object) weak##_##object = object;
#else
#define weakify(object) autoreleasepool{} __block __typeof__(object) block##_##object = object;
#endif
#else
#if __has_feature(objc_arc)
#define weakify(object) try{} @finally{} {} __weak __typeof__(object) weak##_##object = object;
#else
#define weakify(object) try{} @finally{} {} __block __typeof__(object) block##_##object = object;
#endif
#endif
#endif
#ifndef strongify
#if DEBUG
#if __has_feature(objc_arc)
#define strongify(object) autoreleasepool{} __typeof__(object) object = weak##_##object;
#else
#define strongify(object) autoreleasepool{} __typeof__(object) object = block##_##object;
#endif
#else
#if __has_feature(objc_arc)
#define strongify(object) try{} @finally{} __typeof__(object) object = weak##_##object;
#else
#define strongify(object) try{} @finally{} __typeof__(object) object = block##_##object;
#endif
#endif
#endif
使用方法：这两个宏一定成对出现，先weak再strong
@weakify(self) // 定义了一个__weak的self_weak_变量
[self doSomething^{
@strongify(self) // 局域定义了一个__strong的self指针指向self_weak
if (!self) return;
...
}];
五、va_list、va_start、va_arg、va_end的原理与使用
在VC++6.0的include有一个stdarg.h头文件,有如下几个宏定义:
#define _INTSIZEOF(n) ((sizeof(n)+sizeof(int)-1)&~(sizeof(int) - 1) ) //为了满足需要内存对齐的系统
#define va_start(ap,v) ( ap = (va_list)&v + _INTSIZEOF(v) ) //第一个可选参数地址,ap指向第一个变参的位置，即将第一个变参的地址赋予ap(它的第一个参数是指向可变参数字符串的变量，第二个参数是可变参数函数的第一个参数，通常用于指定可变参数列表中参数的个数)
#define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) ) //下一个参数地址,*获取变参的具体内容，t为变参的类型，如有多个参数，则通过移动ap的指针来获得变参的地址，从而获得内容,它的第一个参数指向可变参数字符串的变量，第二个参数是可变参数的类型。
#define va_end(ap) ( ap = (va_list)0 ) // 将指针置为无效, 清空va_list，即结束变参的获取参数在堆栈中分布,位置,在进程中,堆栈地址是从高到低分配的.当执行一个函数的时候,将参数列表入栈,压入堆栈的高地址部分,然后入栈函数的返回地址,接着入栈函数的执行代码,这个入栈过程,堆栈地址不断递减,一些黑客就是在堆栈中修改函数返回地址,执行自己的代码来达到执行自己插入的代码段的目的.总之,函数在堆栈中的分布情况是:地址从高到低,依次是:函数参数列表,函数返回地址,函数执行代码段.堆栈中,各个函数的分布情况是倒序的.即最后一个参数在列表中地址最高部分,第一个参数在列表地址的最低部分.参数在堆栈中的分布情况如下:
最后一个参数
倒数第二个参数
...
第一个参数
函数返回地址
函数代码段
示例代码
void arg_test(int i, ...);
int main(int argc,char *argv[])
{
int int_size = _INTSIZEOF(int);
printf("int_size=%d\n", int_size);
arg_test(0, 4);
arg_cnt(4,1,2,3,4);
return 0;
}
void arg_test(int i, ...)
{
int j=0;
va_list arg_ptr; //定义一个va_list变量arg_ptr,
va_start(arg_ptr, i); //执行ap = (va_list)&v + _INTSIZEOF(v)，ap指向参数v之后的那个参数的地址，即 ap指向第一个可变参数在堆栈的地址。
printf("&i = %p\n", &i);//打印参数i在堆栈中的地址
printf("arg_ptr = %p\n", arg_ptr);//打印va_start之后arg_ptr地址,应该比参数i的地址高sizeof(int)个字节,这时arg_ptr指向下一个参数的地址
j=*((int *)arg_ptr);
printf("%d %d\n", i, j);
j=va_arg(arg_ptr, int); //( *(t *)((arg_ptr += _INTSIZEOF(t)) - _INTSIZEOF(t)) )取出当前ap指针所指的值，并使ap指向下一个参数。 ap＋= sizeof(t类型)，让ap指向下一个参数的地址。然后返回ap-sizeof(t类型)的t类型*指针，这正是第一个可变参数在堆栈里的地址。然后 用*取得这个地址的内容。
printf("arg_ptr = %p\n", arg_ptr);//打印va_arg后arg_ptr的地址,应该比调用va_arg前高sizeof(int)个字节,这时arg_ptr指向下一个参数的地址
va_end(arg_ptr); //清空va_list ap。
printf("%d %d\n", i, j);
}代码说明:
int int_size =_INTSIZEOF(int);得到int类型所占字节数
va_start(arg_ptr, i);得到第一个可变参数地址,
根据定义(va_list)&v得到起始参数的地址,再加上_INTSIZEOF(v) ,就是其实参数下一个参数的地址,即第一个可变参数地址.
j=va_arg(arg_ptr, int); 得到第一个参参数的值,并且arg_ptr指针上移一个_INTSIZEOF(int),即指向下一个可变参数的地址.
va_end(arg_ptr);置空arg_ptr,即arg_ptr=0;
总结:读取可变参数的过程其实就是堆栈中,使用指针,遍历堆栈段中的参数列表,从低地址到高地址一个一个地把参数内容读出来的过程.
在编程中应该注意的问题和解决办法
虽然可以通过在堆栈中遍历参数列表来读出所有的可变参数,但是由于不知道可变参数有多少个,什么时候应该结束遍历,如果在堆栈中遍历太多,那么很可能读取一些无效的数据.
解决办法:
a.可以在第一个起始参数中指定参数个数,那么就可以在循环还中读取所有的可变参数;
b.定义一个结束标记,在调用函数的时候,在最后一个参数中传递这个标记,这样在遍历可变参数的时候,可以根据这个标记结束可变参数的遍历;
8316
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
