结构体中使用指针

最近在方法抽取时，使用了结构体来来支持自定义数值传值，本来一切都顺顺利利，但在处理特定情况，需要在结构体中定义一个传递一个指向数组的指针时，出了问题，指针在用时，拿不到值。

结构体中使用指针

初始使用代码如下

typedef struct {
    int *p;
    int count;
} ZLLAverge;

 ZLLAverge defaultAverge() {
    int a[] = {1, 2, 3};
    ZLLAverge averge;
    averge.count = sizeof(a) / sizeof(int);
    averge.p = a;
    return averge;
}

- (void)test1:(ZLLAverge)averge {
    for (int i = 0; i < averge.count; i++) {
        printf("%i ", averge.p[i]);
         printf("------------\n");
    }
}
- (void)viewDidLoad {
    [super viewDidLoad];
  
    [self test1:defaultAverge()];
  }
//结果如下
0 -1074336348 3 ------------

后面又尝试了两种情况

- (ZLLAverge)ctreateAverge{
    int a[] = {4, 5, 6};
    ZLLAverge averge;
    averge.count = sizeof(a) / sizeof(int);
    averge.p = a;

    return averge;
}
- (void)viewDidLoad {
    [super viewDidLoad];
    
    ZLLAverge averge = [self ctreateAverge];
    [self test1:averge];
 
    ZLLAverge averge1;
     int a[] = {7, 8, 9};;
    averge1.count = sizeof(a) / sizeof(int);
    averge1.p = a;
    [self test1:averge1];
}
//结果如下
0 -1074639484 3 ------------
7 8 9 ------------

尝试到这儿，回想起以前学习的东西，串起来就明白了。

每个函数（方法）在执行时会在栈区分配一块内存空间，在函数内部创建的局部变量就分配在这块内存空间内，当函数执行完时这块内存空间会被回收。但结构体是值传递，所以不受影响，指针的值还在，而上面的指针指向的内存地址中的数据，在函数返回时已被回收，取出的数据就不是我们想要的了。

正确的使用是使用malloc函数，在堆区开辟一块内存空间，同时使用memcpy函数将在栈区的指针指向的内存地址中的数据拷贝到堆区，这样在函数返回时就不会被回收，影响我们的使用了。

 ZLLAverge defaultAverge() {
    int a[] = {1, 2, 3};
    ZLLAverge averge;
    averge.count = sizeof(a) / sizeof(int);
 
    size_t memory_size = averge.count * sizeof(int);
    int *newA = (int *)malloc(memory_size);
    memcpy(newA, a, memory_size);
    averge.p = newA;
    return averge;
}
//
1 2 3 ------------

PS：注意 使用malloc函数开辟的内存空间，要自己释放，不然会有内存泄露。

优雅的使用

上面我们已经解决了问题，但如果我们的代码是提供给别人用的呢，如何给提示信息，注意上面提到的问题呢。或者如果要在别的结构体中使用有指针的结构体呢。有很多方法，但怎样做才简单而优雅呢，在定义这种类型的结构体时提供创建和销毁方法，代码如下：

//再加一些注释就更完美了
typedef struct {
    int *p;
    int count;
} ZLLAverge;
static void avergeRelease(ZLLAverge averge) {
    if (averge.p) {
        free(averge.p);
    }
}
static ZLLAverge avergeCreate(int a[], int count) {
    size_t memory_size = count * sizeof(int);
    int *newA = (int *)malloc(memory_size);
    memcpy(newA, a, memory_size);
    ZLLAverge averge;
    averge.p = newA;
    averge.count = count;
    return averge;
}

注意顺序，销毁方法在前，创建方法在后。这种可以最大程度的提醒使用者正确的使用方法。

如果要在别的结构体中使用有指针的结构体

typedef struct {
    ZLLAverge averge;
    int topMargin;
} ZLLAttiStringValue;
static void attiStringValueRelease(ZLLAttiStringValue stringValue) {
    avergeRelease(stringValue.averge);
}
static ZLLAttiStringValue attiStringValueCreate(int a[], int count) {
    ZLLAttiStringValue stringValue;
    if (a) {
            stringValue.averge = avergeCreate(a, count);
    }
    return stringValue;
}

也要提供创建和销毁方法。

小结

• 注意不能在创建函数内部求count，只能通过外面传进来，因为函数调用过程，sizeof(指针)返回的是指针的字节，而不是数组的长度。
• 不能在结构体中使用OC对象类型，OC对象类型本质是个指针，是在堆上开辟内存空间了的，而在及结构体销毁方法里，我们是没法调用OC对象的销毁方法的

我们把oc对象转为cf对象来看下引用计数

@interface ZLLFont : UIFont

@end
@implementation ZLLFont
- (void)dealloc {
    NSLog(@"......");
}


@end
typedef struct {
    ZLLAverge averge;
    int topMargin;
    ZLLFont *font;
} ZLLAttiStringValue;
static void attiStringValueRelease(ZLLAttiStringValue stringValue) {
    avergeRelease(stringValue.averge);
    if (stringValue.font) {
        CFTypeRef objCF = (__bridge_retained  CFTypeRef)stringValue.font;
         NSLog(@"release --- 引用计数 --- %ld", CFGetRetainCount(objCF));
        CFRelease(objCF);
        NSLog(@"release --- 引用计数 --- %ld", CFGetRetainCount(objCF));
        stringValue.font = nil;
    }
}
static ZLLAttiStringValue attiStringValueCreate(int a[], int count) {
    ZLLAttiStringValue stringValue;
    if (a) {
        stringValue.averge = avergeCreate(a, count);
    }
    stringValue.font = [ZLLFont systemFontOfSize:12];
    return stringValue;
}

- (void)viewDidLoad {
    [super viewDidLoad];
    
    ZLLAttiStringValue stringValue = attiStringValueCreate(nil, 0);
    
    attiStringValueRelease(stringValue);
}
//
release --- 引用计数 --- 4
release --- 引用计数 --- 3

尝试了多次调用CFRelease也不行。