Airths

汇编（十一）

C 语言的条件编译（Conditional Compile）

一般编译器的预编译指令，分为以下4类：
1. 文件包含：例如 #include，是一种最为常见的预处理，用于文件的引用
2. 条件编译：例如 #if、#ifdef、#ifndef、#endif，预编译时进行有选择的编译，注释掉一些指定的代码，以达到版本控制、防止对文件重复包含的功能
3. 布局控制：例如 #pragma，主要功能是为编译程序提供非常规的控制流信息
4. 宏替换：例如 #define，它可以定义符号常量、功能函数、进行重新命名和字符串的拼接等等
条件编译
#if 格式
功能：当表达式的值为真时，编译代码段1，否则编译代码段2。其中，#else 和代码段2 可有可无
```
#if 表达式
	代码段1
#else
	代码段2
#endif
```
#ifdef 格式
功能：当标识符已被定义时（用 #define 定义），编译代码段1，否则编译代码段2。其中 #else 和代码段2 可有可无
```
#ifdef 标识符
	代码段1
#else
	代码段2
#endif
```
#ifndef 格式
功能：当标识符没被定义时（用 #define 定义），编译代码段1，否则编译代码段2。其中 #else 和代码段2 可有可无
```
#ifndef 标识符
	代码段1
#else
	代码段2
#endif
```
注意：
预编译器根据条件编译指令有选择的删除代码，编译器编译时不知道代码分支的存在
#if、#ifdef、#ifndef、#endif 被预编译器处理，而 if … else… 语句被编译器处理
条件编译指令在预编译期进行分支判断，而 if … else … 语句在程序运行期间进行分支判断

#include 和条件编译的应用
#include 的本质是将已经存在的文件内容嵌入到当前文件中，#include 的间接包含同样会产生嵌入文件内容的操作。可以理解为：预编译时， #include 会将指定文件的内容复制到 #include 所在的位置。
如下代码会在 main.c 中产生重复定义问题：

// ---------------- Calc00.h ----------------
#include 

int add(int num0, int num1);

int sub(int num0, int num1);



// ---------------- Calc00.c ----------------
#include "Calc00.h"

int add(int num0, int num1) {
    return num0 + num1;
}
 
int sub(int num0, int num1) {
    return num0 - num1;
}

// ---------------- Calc01.h ----------------
#include 
#include "Calc00.h"

int multipl(int num0, int num1);

int divis(int num0, int num1);

int mix(int num0, int num1);
 


// ---------------- Calc01.c ----------------
#include "Calc01.h"

int multipl(int num0, int num1) {
    return num0 * num1;
}

int divis(int num0, int num1) {
    if (0 == num1) {
        return 0;
    }
    return num0 / num1;
}

int mix(int num0, int num1) {
    return multipl(add(num0, num1), sub(num0, num1));
}

// ---------------- main.c ----------------
#include 
#include "Calc00.h"
#include "Calc01.h"

int main(int argc, const char * argv[]) {
    int result = add(1, 2);
    return 0;
}

在 XCode 中编译 C 或者 Objective-C 代码时，其实参与编译的只有 .c 文件和 .m 文件，.h文件是不参与编译的。我们可以在 Build Phases - Compile Sources 中看到，参与编译的只有 .c 文件和 .m 文件：

但是因为我们在 .c 文件中，使用了 #include 导入头文件；在 .m 文件中使用了 #import 导入头文件，所以（C 和 Objective-C）头文件 .h 里面的内容，实际上也会参与编译。

在 XCode 中，创建 C 代码的时候，.h 文件里面默认会生成如下预编译指令，这些预编译指令的作用就是防止重复导入（相当于 Objective-C 中 #improt 的功能）：
Test.h 里面的内容如下：

#ifndef Test_h
#define Test_h

#include 

// 这里编写代码
 
#endif /* Test_h */

Test.c 里面的内容如下：

#include "Test.h"

// 这里编写代码

Objective-C 中的 bridge、bridge_retained、__bridge_transfer

__bridge 只做类型转换，但是不修改对象（内存）管理权
__bridge_retained（也可以使用 CFBridgingRetain）将 Objective-C 的对象转换为 Core Foundation 的对象，同时将对象（内存）的管理权交给程序员，后续需要使用 CFRelease 或者相关方法来释放对象
__bridge_transfer（也可以使用 CFBridgingRelease）将 Core Foundation 的对象转换为 Objective-C 的对象，同时将对象（内存）的管理权交给ARC

初识 LLDB

LLDB 全称为 Low Level Debugger ，并不是低水平的调试器，而是轻量级的高性能调试器，默认内置于 Xcode 中，是 XCode 默认的调试器。我们平时用 Xcode 运行程序，实际走的都是 LLDB

在本节中，只需要了解 LLDB 的 x 指令即可

x 指令相当于 memory read 指令，是 memory read 指令的缩写

使用方式：

// 读取从 list 地址开始的，16 个 Byte 的内存数据，并以 16 进制显式
(lldb) x/16bx list
0x100534f10: 0x0a 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x100534f18: 0x60 0x56 0x53 0x00 0x01 0x00 0x00 0x00

// 读取从 list 地址开始的，16 个 Word 的内存数据，并以 16 进制显式
// 注意，在 64bit 的 CPU 里面，1Word == 4Byte
(lldb) x/16wx list
0x100534f10: 0x0000000a 0x00000000 0x00535660 0x00000001
0x100534f20: 0x534e5b2d 0x63756f54 0x72614268 0x6f6c6f43
0x100534f30: 0x73694c72 0x63695074 0x4272656b 0x4372756c
0x100534f40: 0x61746e6f 0x72656e69 0x77656956 0x696e6920

HCGLinearList 封装

上一篇中虽然完成了 HCGLinearList 的功能，但没有对其进行封装和优化，HCGLinearList 还存在以下缺陷：

LinearList 结构体的定义暴露在 .h 文件中，外界可以直接拿到 LinearList 结构体的成员进行操作。如：通过设置 LinearList.length = 0，就可以达到清空线性表的目的（listClear() 函数形同虚设）；将 LinearList.length 的值设置得比 LinearList.capacity 的值大；通过修改LinearList.capacity 的值企图修改线性表的容量；通过 LinearList.value 直接操作存储在线性表中的元素，修改 LinearList.value 指向的内存地址等等
由于线性表中定义的 LinearListNodeValue 为 int 类型，所以线性表只能存储 int 类型的数据，不够通用

基于以上分析，对 HCGLinearList 做如下修改：

将 HCGLinearList.h 中对 LinearList 结构体的定义放到 HCGLinearList.c，对外只暴露一个 void 类型的 LinearList，这样外界无法知道 LinearList 的具体定义，也就修改不了 LinearList 结构体的成员了。同时，使用条件编译，防止在 HCGLinearList.h 和 HCGLinearList.c 中对结构体 LinearList 和指针 LinearListNodeValue 进行重复定义。

将 LinearListNodeValue 的类型由 int 改为 void*，即表明线性表存储的节点数据为指针类型。那么此时 LinearList.value 为指向指针数据的指针。
HCGLinearList.h 如下：

// -------------------------------- HCGLinearList.h --------------------------------
#ifndef LinearList_h
#define LinearList_h

#include 

#pragma mark -  宏定义（条件编译）
#ifndef LINEARLIST_STRUCT

// 线性表节点数据
typedef void* LinearListNodeValue;
// 线性表
typedef void LinearList;

#endif

#pragma mark - 创建 销毁 清空
// 创建线性表
// param0.线性表容量
// return.线性表指针
LinearList* listCreat(int capacity);

// 销毁线性表
// param0.线性表指针
void listRelease(LinearList* list);

// 清空线性表
// param0.线性表指针
void listClear(LinearList* list);

#pragma mark - 属性获取
// 获取线性表的长度
// param0.线性表指针
// return.线性表长度
int listLength(LinearList* list);

// 获取线性表容量
// param0.线性表指针
// return.线性表容量
int listCapacity(LinearList* list);

#pragma mark - 增
// 往线性表中插入数据
// param0.线性表指针
// param1.要插入的位置的索引
// param2.要插入的值
void listInsert(LinearList* list, int index, LinearListNodeValue value);

// 往线性表中添加数据（添加在表尾）
void listAdd(LinearList* list, LinearListNodeValue value);

#pragma mark - 删
// 删除线性表中指定索引位置的元素
// param0.线性表指针
// param1.索引
void listRemove(LinearList* list, int index);

#pragma mark - 改
// 修改线性表中指定位置的元素为指定的值
// param0.线性表指针
// param1.索引
// param2.值
void listSet(LinearList* list, int index, LinearListNodeValue value);

#pragma mark - 查
// 获取线性表指定索引处元素的值
// param0.线性表指针
// param1.索引
// return.元素的值
LinearListNodeValue listGet(LinearList* list, int index);

#pragma mark - 特殊功能
// 删除线性表中具有指定值的所有元素
// param0.线性表指针
// param1.要删除的值
void listRemoveValue_1(LinearList* list, LinearListNodeValue value);

// 删除线性表中具有指定值的所有元素
// param0.线性表指针
// param1.要删除的值
void listRemoveValue_2(LinearList* list, LinearListNodeValue value);

// 打印线性表
// param0.线性表指针
void listPrint(LinearList* list);

#endif /* LinearList_h */

HCGLinearList.c 如下：

// -------------------------------- HCGLinearList.c --------------------------------
#pragma mark - 定义线性表结构体

// 数据节点指针
typedef void* LinearListNodeValue;

// 线性表结构体
typedef struct {
    int capacity;               // 容量
    int length;                 // 长度
    LinearListNodeValue* value; // 节点数据的指针(相当于 void** value，指向指针的指针)
} LinearList;

/*
 注意：宏 LINEARLIST_STRUCT 的定义，一定要在导入 HCGLinearList.h 之前
 这是为了防止上面的 LinearListNodeValue 指针和 LinearList 结构体被重复定义
 **/
//
#define LINEARLIST_STRUCT

#pragma mark - 导入头文件
#include "HCGLinearList.h"

// 使用 mallc函数 需要导入
#include 

#pragma mark - 创建 销毁 清空
// 创建线性表
LinearList* listCreat(int capacity) {
    if (capacity < 0) {
        return NULL;
    }
    // 分配线性表结构体的内存空间（在堆区）
    // malloc函数如果遇到内存资源紧张，给不了这么多字节，可能会返回空
    LinearList* list = malloc(sizeof(LinearList));
    if (list) {
        list->capacity = capacity;
        list->length = 0;
        // 分配存储线性表元素的内存空间
        list->value = malloc(capacity * sizeof(LinearListNodeValue));
        if (!list->value) {
            return NULL;
        }
    }
    return list;;
}

// 销毁线性表
void listRelease(LinearList* list) {
    if (NULL == list) {
        return;
    }
    if (list->value) {
        free(list->value);
    }
    free(list);
}

// 清空线性表
void listClear(LinearList* list) {
    if (NULL == list) {
        return;
    }
    // 这里不需要对线性表中的元素都置0
    // 只要将线性表的长度置为0，下次使用线性表的时候，就会对之前的数据进行覆盖了
    list->length = 0;
}

#pragma mark - 属性获取
// 获取线性表的长度
int listLength(LinearList* list) {
    if (NULL == list) {
        return 0;
    }
    return list->length;
}

// 获取线性表容量
int listCapacity(LinearList* list) {
    if (NULL == list) {
        return 0;
    }
    return list->capacity;
}

#pragma mark - 增
// 往线性表中插入数据
void listInsert(LinearList* list, int index, LinearListNodeValue value) {
    if (NULL == list) {
        return;
    }
    // 可以在表尾进行插入，因此这里的条件是 index > list->length，而不是 index >= list->length
    if (index < 0 || index > list->length) {
        return;
    }
    if (list->length == list->capacity) {
        return;
    }
    
    // 反向for循环挪动数据：从表尾数据开始挪动直到index标识的位置，每个数据依次向后挪动一个步长
    for (int i = list->length - 1; i >= index; i--) {
        list->value[i + 1] = list->value[i];
    }
    // 将新值value插入到index的位置
    list->value[index] = value;
    // 线性表的长度 + 1
    list->length++;
}

// 往线性表中添加数据（添加在表尾）
void listAdd(LinearList* list, LinearListNodeValue value) {
    if (NULL == list) {
        return;
    }
    listInsert(list, list->length, value);
}

#pragma mark - 删
// 删除线性表中指定索引位置的元素
void listRemove(LinearList* list, int index) {
    if (NULL == list) {
        return;
    }
    if (index < 0 || index > list->length - 1) {
        return;
    }
    // 反向for循环挪动数据：从(index + 1)标识的位置开始直到表尾，每个数据依次向前挪动一个步长
    for (int i = index + 1; i < list->length; i++) {
        list->value[i - 1] = list->value[i];
    }
    /*
    // 等效写法
    for (int i = index; i < list->length - 1; i++) {
        list->value[i] = list->value[i + 1];
    }
    */
    // 线性表的长度 - 1
    list->length--;
}

#pragma mark - 改
// 修改线性表中指定位置的元素为指定的值
void listSet(LinearList* list, int index, LinearListNodeValue value) {
    if (NULL == list) {
        return;
    }
    if (index < 0 || index > list->length - 1) {
        return;
    }
    list->value[index] = value;
}

#pragma mark - 查
// 获取线性表指定索引处元素的值
LinearListNodeValue listGet(LinearList* list, int index) {
    if (NULL == list) {
        return 0;
    }
    if (index < 0 || index > list->length - 1) {
        return 0;
    }
    return list->value[index];
}

#pragma mark - 特殊功能
// 删除线性表中具有指定值的所有元素 - 代码简单，但是效率低（时间复杂度高）
void listRemoveValue_1(LinearList* list, LinearListNodeValue value) {
    if (NULL == list) {
        return;
    }
    // 遍历所有元素
    for (int i = 0; i <= list->length - 1; i++) {
        while (list->value[i] == value && i <= list->length - 1) {
            listRemove(list, i);
        }
    }
}

// 删除线性表中具有指定值的所有元素 - 效率较高
void listRemoveValue_2(LinearList* list, LinearListNodeValue value) {
    if (NULL == list) {
        return;
    }
    // 遍历所有元素
    int removeCount = 0;
    for (int i = 0; i <= list->length - 1; i++) {
        if (list->value[i] == value) {
            removeCount++;
        } else {
            list->value[i - removeCount] = list->value[i];
        }
    }
    // 将长度减去删除的个数
    list->length -= removeCount;
}

// 打印线性表
void listPrint(LinearList* list) {
    if (NULL == list) {
        return;
    }
    printf("list{\n");
    printf("\tlength = %d;\n", list->length);
    printf("\tcapacity = %d;\n", list->capacity);
    printf("\tvalue = [");
    for (int i = 0; i <= list->length - 1; i++) {
        printf("%p", list->value[i]);
        if (i <= list->length - 2) {
            printf(",");
        }
    }
    printf("];\n\t}\n\n");
}

Person.h 和 Person.m 如下：

// -------------------------------- Person.h --------------------------------
#import 

NS_ASSUME_NONNULL_BEGIN

@interface Person : NSObject

#pragma mark - 属性
// 姓名
@property (nonatomic, copy) NSString* name;

// 年龄
@property (nonatomic, assign) int age;

#pragma mark - 构造方法
+(instancetype)personWithName:(NSString *)name
                           age:(int)age;

-(instancetype)initWithName:(NSString *)name
                         age:(int)age;

#pragma mark - 对象方法
-(void)introduce;

@end

NS_ASSUME_NONNULL_END

 

// -------------------------------- Person.m --------------------------------
#import "Person.h"

@implementation Person

#pragma mark - 构造方法
+(instancetype)personWithName:(NSString *)name age:(int)age {
    return [[self alloc] initWithName:name age:age];
}

-(instancetype)initWithName:(NSString *)name age:(int)age {
    if (self = [super init]) {
        self.name = name;
        self.age = age;
    }
    return self;
}

#pragma mark - 对象方法
-(void)introduce {
    NSLog(@"Hello, I am %@, I am %d year old!", self.name, self.age);
}

@end

main.m 如下：

#import 
#import "HCGLinearList.h"
#import "Person.h"

// 线性表存储基本数据类型
void saveElementaryDemo() {
    LinearList* list = listCreat(10);
    // 基本数据类型，需要强转为 LinearListNodeValue（即 void*）类型后再保存到线性表里面
    listAdd(list, (LinearListNodeValue)1);
    listAdd(list, (LinearListNodeValue)2);
    listAdd(list, (LinearListNodeValue)3);
    listAdd(list, (LinearListNodeValue)4);
    listPrint(list);
    /* 打印结果：value[] 里面以 16进制保持着 0 1 2 3 4
	list{
		length = 5;
		capacity = 10;
		value = [0x0,0x1,0x2,0x3,0x4];
		}
	*/
	
    listRelease(list);
    list = NULL;
}

// 线性表存储指针类型
void savePointerDemo() {
    LinearList* list = listCreat(10);
 	// Objective-C 的对象本质上（在底层）就是一个结构体的指针
    Person* person0 = [Person personWithName:@"P0" age:0];
    Person* person1 = [Person personWithName:@"P1" age:1];
    Person* person2 = [Person personWithName:@"P2" age:2];
    NSLog(@"%p,%p,%p", person0, person1, person2);
    // 输出结果
    // 0x1004b1620,0x1004b1bf0,0x1004b1c10
    
    // __bridge 是给编译器看的，告诉编译器将 Objective-C 环境下的对象，变成 C 环境下的指针类型。
    // 通过 __bridge 将 Objective-C 环境下的 Person 对象，转换为 C 环境下的 LinearListNodeValue（void*）类型
    listAdd(list, (__bridge LinearListNodeValue)(person0));
    listAdd(list, (__bridge LinearListNodeValue)(person1));
    listAdd(list, (__bridge LinearListNodeValue)(person2));
    listPrint(list);
    /* 打印结果（value[] 里面保存的值，为 person0, person1, person2 的地址，即 value[] 里面保存的是指针）：
    list{
        length = 3;
        capacity = 10;
        value = [0x1004b1620,0x1004b1bf0,0x1004b1c10];
        }
    */
    
    // 取出节点数据
    Person* p = (__bridge Person *)(listGet(list, 0));
    [p introduce];
    // 打印结果：
    // Hello, I am P0, I am 0 year old!
    
    listRelease(list);
    list = NULL;
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
    	// saveElementaryDemo();
        // savePointerDemo();
    }
    return 0;
}

这里有个有趣的地方：
Objective-C 的 NSArray、NSMutableArray，可以直接存放对象，但是如果要存放基本数据类型，则需要对基本数据类型进行包装。
C 的 LinearList，可以直接存放指针类型，但是存放基本数据类型需要强转，存放 Objective-C 对象需要桥接。

LLDB 内存分析与逆向初步

通过 LLDB 对 LinearList 的内存进行分析
main 函数中的代码如下：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        LinearList* list = listCreat(10);
        
        listAdd(list, (LinearListNodeValue)0);
        listAdd(list, (LinearListNodeValue)1);
        listAdd(list, (LinearListNodeValue)2);
        listAdd(list, (LinearListNodeValue)3);
        listAdd(list, (LinearListNodeValue)4);
        listPrint(list);
        
        listRelease(list);
        list = NULL;
    }
    return 0;
}

通过 LLDB 读取 list 的内存进行分析，我们可以看到：

由于 LinearList 的 length（int）、capacity（int）、value（void*）分别占用 4Byte、4Byte、8Byte，而且结构体的成员在内存中的存储顺序与结构体成员在结构体中的定义顺序是一致的，所以可以看出
list->capacity = 10
list->length = 5
list->value = 0x00000001005a6f90
LLDB 控制台输出如下：
```
(lldb) x/32xb list
0x10059d8b0: 0x0a 0x00 0x00 0x00 0x05 0x00 0x00 0x00
0x10059d8b8: 0x90 0x6f 0x5a 0x00 0x01 0x00 0x00 0x00
0x10059d8c0: 0x2d 0x5b 0x4e 0x53 0x54 0x61 0x62 0x50
0x10059d8c8: 0x69 0x63 0x6b 0x65 0x72 0x56 0x69 0x65
```

通过 LLDB 读取 list->value 保存的地址，可以看到存储在堆区的线性表 list 的元素的值

(lldb) x/96xb 0x01005a6f90
0x1005a6f90: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x1005a6f98: 0x01 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x1005a6fa0: 0x02 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x1005a6fa8: 0x03 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x1005a6fb0: 0x04 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x1005a6fb8: 0x74 0xa3 0x05 0x10 0x00 0x00 0x00 0x20
0x1005a6fc0: 0x66 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x1005a6fc8: 0x00 0x00 0x00 0x00 0x00 0x00 0x02 0x00
0x1005a6fd0: 0x28 0x65 0x78 0x70 0x65 0x72 0x69 0x6d
0x1005a6fd8: 0x65 0x6e 0x74 0x61 0x6c 0x5f 0x6d 0x61
0x1005a6fe0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x1005a6fe8: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

通过 LLDB 对 NSArray 的内存进行分析
main 函数中的代码如下：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 注意：
        // 1.字符串常量，在编译的那一刻，地址就确定了，不会再发生改变
        // 2.根据字符串的这一特性，可以利用字符串的地址，反推 NSArray 存储数组元素的位置
        NSString* name0 = @"jack";
        NSString* name1 = @"jones";
        NSString* name2 = @"hcg";
        NSString* name3 = @"hzp";
		NSArray* array = @[name0, name1, name2, name3];
		
        NSLog(@"name0 = %p, name1 = %p, name2 = %p, name3 = %p", name0, name1, name2, name3);
        NSLog(@"array = %@", array);
        NSLog(@"array.count = %ld", array.count);
        /* 输出结果如下：
        name0 = 0x100002048, name1 = 0x100002068, name2 = 0x100002088, name3 = 0x1000020a8
        array = (
		jack,
		jones,
		hcg,
		hzp
		)
		array.count = 4
		*/
    }
    return 0;
}

通过 LLDB 读取 array 的内存进行分析，我们可以看到：
NSArray 存储数组对象的属性与元素的内存空间是连续的
我们可以猜测，NSArray 底层可能只通过一次 malloc 就一次性开辟了存储数组对象的属性和元素的内存空间
而不是像 HCGLinearList 那样使用两次 malloc，一次用于开辟存储数组属性的内存空间，一次用于开辟存储数组元素的内存空间
这样做的好处是：少调用了一次 malloc 和 free，代码简洁，提高了性能
属性和元素放在连续的内存空间里，根据局部性原理，也可以提高性能
注意：可以通过反复修改不可变数组的长度再并运行，来确定：不可变数组在内存中的第二个8字节，是用来存储数组的 count 属性。

(lldb) x/64xb array
0x10060d5f0: 0x59 0xf4 0xbd 0x8c 0xff 0xff 0x1d 0x01
0x10060d5f8: 0x04 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x10060d600: 0x48 0x20 0x00 0x00 0x01 0x00 0x00 0x00
0x10060d608: 0x68 0x20 0x00 0x00 0x01 0x00 0x00 0x00
0x10060d610: 0x88 0x20 0x00 0x00 0x01 0x00 0x00 0x00
0x10060d618: 0xa8 0x20 0x00 0x00 0x01 0x00 0x00 0x00
0x10060d620: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x10060d628: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
(lldb) po 0x0100002048
jack
(lldb) po 0x0100002068
jones
(lldb) po 0x0100002088
hcg
(lldb) po 0x01000020a8
hzp

拓展
原本 NSArray 的 count 为只读属性，但是我们可以通过定位到 array 对象在内存中的地址，通过直接操作内存，来修改 array.count

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 注意：
        // 1.字符串常量，在编译的那一刻，地址就确定了，不会再发生改变
        // 2.根据字符串的这一特性，可以利用字符串的地址，反推 NSArray 存储数组元素的位置
        NSString* name0 = @"jack";
        NSString* name1 = @"jones";
        NSString* name2 = @"hcg";
        NSString* name3 = @"hzp";
        NSArray* array = @[name0, name1, name2, name3];
        NSLog(@"name0 = %p, name1 = %p, name2 = %p, name3 = %p", name0, name1, name2, name3);
        NSLog(@"array = %@", array);
        NSLog(@"array.count = %ld", array.count);
        /* 输出结果：
        name0 = 0x100002048, name1 = 0x100002068, name2 = 0x100002088, name3 = 0x1000020a8
        array = (
            jack,
            jones,
            hcg,
            hzp
        )
        array.count = 4
        **/
        // 直接操作内存，修改 NSArray 的只读属性 count
        // 注意：iOS 底层有防御性编程，不可变数组 array 初始化时的容量为4，即系统为不可变数组分配的内存空间大小为 4 * 8Byte = 32Byte
        // 如果将 array.count 修改为小于等于 4 的数值，程序可以运行通过。
        // 但是如果将 array.count 修改为 大于 4 的数值，由于运行时发生内存越界，程序会奔溃。
        void* address = (__bridge void*)array;
        *((long *)address + 1) = 2;
        // 打印输出
        NSLog(@"array.count = %ld", array.count);
        NSLog(@"array = %@", array);
        /* 输出结果：
        array.count = 2
        array = (
            jack,
            jones
        )
        **/
    }
    return 0;
}

修改后，通过 LLDB 读取 array 的内存地址，可以看到，存储 count 属性值的内存地址，已经被修改为 2（原先的值为 4）

(lldb) x/64xb array
0x10060beb0: 0x59 0xf4 0xbd 0x8c 0xff 0xff 0x1d 0x01
0x10060beb8: 0x02 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x10060bec0: 0x48 0x20 0x00 0x00 0x01 0x00 0x00 0x00
0x10060bec8: 0x68 0x20 0x00 0x00 0x01 0x00 0x00 0x00
0x10060bed0: 0x88 0x20 0x00 0x00 0x01 0x00 0x00 0x00
0x10060bed8: 0xa8 0x20 0x00 0x00 0x01 0x00 0x00 0x00
0x10060bee0: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x10060bee8: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00

NSMutableArray 扩容分析

Objective-C 中的数组
Objective-C 中的数组本身是一个对象，数组中存放的元素是对象的引用
Objective-C 中的数组分为：不可变数组（NSArray）和可变数组（NSMutableArray）
不可变数组（NSArray）初始化之后不能修改数组的内容
可变数组（NSMutableArray）初始化之后可以随时修改数组的内容（增加元素，删除元素，修改元素）
可变数组的容量：
1. 随着数组元素的增加而动态地增加
2. 随着数组元素的删除而动态的减少

通过 LLDB 对 NSMutableArray 的内存进行分析
main 函数中的代码如下：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 打印字符串常量的地址
        NSString* str = @"jack";
        NSLog(@"str addr = %p", str);
        
        // 创建可变数组
        int capacity = 0;
        NSMutableArray* mArr = [NSMutableArray arrayWithCapacity:capacity];

        // 往数组里面添加元素
        int total = 10;
        for (int i = 0; i < total; i++) {
            [mArr addObject:str];
        }
    }
    return 0;
}

通过 LLDB 查看 mArr 的内存情况：

str addr = 0x100002048
(lldb) x/96xb mArr
0x100535720: 0x89 0xdd 0xbd 0x8c 0xff 0xff 0x1d 0x01
0x100535728: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x100535730: 0xc0 0x5a 0x53 0x00 0x01 0x00 0x00 0x00
0x100535738: 0x00 0x00 0x00 0x00 0x0a 0x00 0x00 0x00
0x100535740: 0x0b 0x00 0x00 0x00 0x0a 0x00 0x00 0x00
0x100535748: 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
0x100535750: 0x2d 0x5b 0x4e 0x53 0x54 0x69 0x74 0x6c
0x100535758: 0x65 0x62 0x61 0x72 0x43 0x6f 0x6e 0x74
0x100535760: 0x61 0x69 0x6e 0x65 0x72 0x56 0x69 0x65
0x100535768: 0x77 0x20 0x74 0x69 0x74 0x6c 0x65 0x48
0x100535770: 0x65 0x69 0x67 0x68 0x74 0x54 0x6f 0x48
0x100535778: 0x69 0x64 0x65 0x49 0x6e 0x46 0x75 0x6c

发现：
字符串常量 str 的地址，并没有保存在可变数组 mArr 的堆区
我们推测，可变数组 mArr 应该是在堆区另外开辟了一段内存空间用于存储 mArr 的元素
在可变 mArr 的堆区，应该会有 8Byte 的内存空间，记录着指向 mArr 存储数组元素的堆区的首地址
观察可变 mArr 堆区的内存数据，发现：第 3 行的数值，非常像一个堆区的内存地址
因此，将第 3 行当成内存地址，并进行打印：

(lldb) x/96xb 0x0100535ac0
0x100535ac0: 0x48 0x20 0x00 0x00 0x01 0x00 0x00 0x00
0x100535ac8: 0x48 0x20 0x00 0x00 0x01 0x00 0x00 0x00
0x100535ad0: 0x48 0x20 0x00 0x00 0x01 0x00 0x00 0x00
0x100535ad8: 0x48 0x20 0x00 0x00 0x01 0x00 0x00 0x00
0x100535ae0: 0x48 0x20 0x00 0x00 0x01 0x00 0x00 0x00
0x100535ae8: 0x48 0x20 0x00 0x00 0x01 0x00 0x00 0x00
0x100535af0: 0x48 0x20 0x00 0x00 0x01 0x00 0x00 0x00
0x100535af8: 0x48 0x20 0x00 0x00 0x01 0x00 0x00 0x00
0x100535b00: 0x48 0x20 0x00 0x00 0x01 0x00 0x00 0x00
0x100535b08: 0x48 0x20 0x00 0x00 0x01 0x00 0x00 0x00
0x100535b10: 0x03 0x3c 0x14 0x79 0xff 0x7f 0x00 0x00
0x100535b18: 0x9a 0x20 0x52 0xb8 0x00 0x00 0x00 0x00

我们看到了在 0x0100535ac0 这段内存地址中，存储着 10 个字符串常量 str 的地址
由此可以确定，可变数组 mArr 堆区的第 3 行（8Byte）记录着指向存储数组元素的堆区的首地址

修改 main 函数中的变量 capacity 和 total，反复进行单步调试并通过 LLDB 打印 mArr 每次添加元素后堆区的内存变化
我们发现：

当可变数组 mArr 的元素添加到一定程度时，mArr 堆区第 3 行（记录着指向存储数组元素的堆区的首地址）的数值会发生改变，即 mArr 进行了扩容
当 mArr 堆区第 3 行的数值发生改变时，mArr 堆区第 4 行的后 4 个字节的数值，也会增加一点，猜测其数值为可变数组 mArr 的当前容量（capacity）
可变数组 mArr 每次添加元素时，mArr 堆区第 5 行的前 4 个字节和后 4 个字节，都会 + 1。并且：
mArr 堆区第 5 行的前 4 个字节永远 == 当前元素数量 + 1
mArr 堆区第 5 行的后 4 个字节永远 == 当前元素数量
我们猜测：
mArr 堆区第 5 行的前 4 个字节作用未知
mArr 堆区第 5 行的后 4 个字节为 mArr.count

为了更好地分析 NSMutableArray 的扩容机制，编写 NSMutableArray 的分类 MemoryAnalyse 如下：

// -------------------------------- NSMutableArray+MemoryAnalyse.h --------------------------------
#import 

NS_ASSUME_NONNULL_BEGIN

@interface NSMutableArray (MemoryAnalyse)

// 返回存储数组的元素的堆区的首地址
-(void *)elementHeapAddress;

// 获取当前数组的容量
-(int)getCurrentCapacity;

// 设置当前数组的容量
-(void)setCurrentCapacity:(int)capacity;

// 获取当前数组的元素个数
-(int)getCurrentCount;

// 设置当前数组的元素个数
-(void)setCurrentCount:(int)count;

@end

NS_ASSUME_NONNULL_END

// -------------------------------- NSMutableArray+MemoryAnalyse.m --------------------------------
#import "NSMutableArray+MemoryAnalyse.h"

@implementation NSMutableArray (MemoryAnalyse)

// 返回存储数组的元素的堆区的首地址
-(void *)elementHeapAddress {
    // 获取数组对象的首地址
    void* arrAddress = (__bridge void*)self;
    // void* 为万能指针，可以指向任意数据类型，即 void*指针 的步长是不确定
    // 因此，void* 类型的指针，不能直接通过 + 或 - 来移动指针
    // void** 为 指向 void*类型 的指针，其步长为确定的 8Byte（因为 void* 占8个字节 ）（因为在 64bit CPU 下，一个指针占 8Byte）。
    // 根据之前的观察，NSMutableArray 的第 3 行是 存储数组的元素的堆区的首地址
    // 偏移量为 3 * 8Byte = 24Byte，步数从 0 开始计算，void** 的步长为 8Byte，则有 24 / 8 - 1 = 2
    void* elementHeapAddress = *((void **)arrAddress + 2);
    return elementHeapAddress;
}

// 获取当前数组的容量
-(int)getCurrentCapacity {
    // 获取数组对象的首地址
    void* arrAddress = (__bridge void*)self;
    // 根据之前的观察，NSMutableArray 的第 4 行的后 4 个 Byte 为 当前数组的容量
    // 偏移量为 4 * 8Byte = 32Byte，步数从 0 开始计算，int* 步长为 4Byte，则有 32 / 4 - 1 = 7
    return *((int *)arrAddress + 7);
}

// 设置当前数组的容量
-(void)setCurrentCapacity:(int)capacity {
    // 获取数组对象的首地址
    void* arrAddress = (__bridge void*)self;
    // 根据之前的观察，NSMutableArray 的第 4 行的后 4 个 Byte 为 当前数组的容量
    // 偏移量为 4 * 8Byte = 32Byte，步数从 0 开始计算，int* 步长为 4Byte，则有 32 / 4 - 1 = 7
    *((int *)arrAddress + 7) = capacity;
}

// 获取当前数组的元素个数
-(int)getCurrentCount {
    // 获取数组对象的首地址
    void* arrAddress = (__bridge void*)self;
    // 根据之前的观察，NSMutableArray 的第 5 行的后 4 个 Byte 为 当前数组的元素个数
    // 偏移量为 5 * 8Byte = 40Byte，步数从 0 开始计算，int* 步长为 4Byte，则有 40 / 4 - 1 = 9
    return *((int *)arrAddress + 9);
}

// 设置当前数组的元素个数
-(void)setCurrentCount:(int)count {
    // 获取数组对象的首地址
    void* arrAddress = (__bridge void*)self;
    // 根据之前的观察，NSMutableArray 的第 5 行的后 4 个 Byte 为 当前数组的元素个数
    // 偏移量为 5 * 8Byte = 40Byte，步数从 0 开始计算，int* 步长为 4Byte，则有 40 / 4 - 1 = 9
    *((int *)arrAddress + 9) = count;
}

@end

在 main 函数中，编写代码，分析 NSMutableArray 的扩容机制：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 打印字符串常量的地址
        NSString* str = @"jack";
        NSLog(@"str addr = %p", str);

        // 创建可变数组
        int capacity = 10;
        NSMutableArray* mArr = [NSMutableArray arrayWithCapacity:capacity];

        // 打印可变数组扩容时机，扩容容量等
        int total = 512;
        int currentTimes = 0;
        int preTimes = currentTimes;
        void* currentElementHeapAddr = mArr.elementHeapAddress;
        // 可变数组的容量，随着数组元素的增加而动态地增加
        NSLog(@"Arr存储了[%03d]个元素时 currentElementHeapAddr = %p, currentCapacity = %d", 0, mArr.elementHeapAddress, [mArr getCurrentCapacity]);
        for (currentTimes = 0; currentTimes < total; currentTimes++) {
            [mArr addObject:str];
            // 存储数组的元素的堆区的首地址发生改变 - 可变数组进行扩容
            if (currentElementHeapAddr != mArr.elementHeapAddress) {
                NSLog(@"currentElementHeapAddr = %p, currentTimes = %03d, capacity = %03d", mArr.elementHeapAddress, currentTimes, [mArr getCurrentCapacity]);
                currentElementHeapAddr = mArr.elementHeapAddress;
                preTimes = currentTimes;
            }
        }
		// 可变数组的容量，随着数组元素的减少而动态地减少
        NSLog(@"Arr存储了[%03d]个元素时 currentElementHeapAddr = %p, currentCapacity = %d", total, mArr.elementHeapAddress, [mArr getCurrentCapacity]);
        for (currentTimes = 0; currentTimes < total; currentTimes++) {
            [mArr removeLastObject];
            // 存储数组的元素的堆区的首地址发生改变 - 可变数组进行扩容
            if (currentElementHeapAddr != mArr.elementHeapAddress) {
                NSLog(@"currentElementHeapAddr = %p, currentTimes = %03d, capacity = %03d", mArr.elementHeapAddress, currentTimes, [mArr getCurrentCapacity]);
                currentElementHeapAddr = mArr.elementHeapAddress;
                preTimes = currentTimes;
            }
        }

		/* 打印输入如下：
		str addr = 0x100003048
		Arr存储了[000]个元素时 currentElementHeapAddr = 0x100751170, currentCapacity = 10
		currentElementHeapAddr = 0x100405730, currentTimes = 010, capacity = 016
		currentElementHeapAddr = 0x100751200, currentTimes = 016, capacity = 026
		currentElementHeapAddr = 0x1007512d0, currentTimes = 026, capacity = 042
		currentElementHeapAddr = 0x100507470, currentTimes = 042, capacity = 068
		currentElementHeapAddr = 0x100507700, currentTimes = 068, capacity = 110
		currentElementHeapAddr = 0x102808200, currentTimes = 110, capacity = 192
		currentElementHeapAddr = 0x102808800, currentTimes = 192, capacity = 320
		currentElementHeapAddr = 0x102809200, currentTimes = 320, capacity = 576
		Arr存储了[512]个元素时 currentElementHeapAddr = 0x102809200, currentCapacity = 576
		currentElementHeapAddr = 0x101009200, currentTimes = 291, capacity = 256
		currentElementHeapAddr = 0x10066f0c0, currentTimes = 414, capacity = 098
		currentElementHeapAddr = 0x10066eb50, currentTimes = 474, capacity = 038
		currentElementHeapAddr = 0x10066efe0, currentTimes = 497, capacity = 014
		currentElementHeapAddr = 0x10066f050, currentTimes = 506, capacity = 006
		currentElementHeapAddr = 0x100661ec0, currentTimes = 509, capacity = 002
		**/
    }
    return 0;
}

注意：
mArr[0] 是获取数组第一个元素的值，我们无法通过 mArr[0] 来获取可变数组存储元素的堆区的首地址
并且我们不能通过常规手段，获取到可变数组存储元素的堆区的首地址

HCGLinearList 扩容

通过上面对 NSMutableArray 的内存进行分析，得到 Objective-C 对于 NSMutableArray 动态变更容量的思路：
1. 当 NSMutableArray 的元素数量增加或减少到一定程度时，就 malloc 出一块适当大小的新的堆空间
2. 将旧堆空间的数据复制到新的堆空间
3. 释放掉旧的堆空间

按照 NSMutableArray 扩容的思路，优化 HCGLinearList 代码：
HCGLinearList.h 文件，相对于上面的代码，没有做任何改变：

#ifndef LinearList_h
#define LinearList_h

#include 

#pragma mark -  宏定义（条件编译）
#ifndef LINEARLIST_STRUCT

// 线性表节点数据
typedef void* LinearListNodeValue;
// 线性表
typedef void LinearList;

#endif

#pragma mark - 创建 销毁 清空
// 创建线性表
// param0.线性表容量
// return.线性表指针
LinearList* listCreat(int capacity);

// 销毁线性表
// param0.线性表指针
void listRelease(LinearList* list);

// 清空线性表
// param0.线性表指针
void listClear(LinearList* list);

#pragma mark - 属性获取
// 获取线性表的长度
// param0.线性表指针
// return.线性表长度
int listLength(LinearList* list);

// 获取线性表容量
// param0.线性表指针
// return.线性表容量
int listCapacity(LinearList* list);

#pragma mark - 增
// 往线性表中插入数据
// param0.线性表指针
// param1.要插入的位置的索引
// param2.要插入的值
void listInsert(LinearList* list, int index, LinearListNodeValue value);

// 往线性表中添加数据（添加在表尾）
void listAdd(LinearList* list, LinearListNodeValue value);

#pragma mark - 删
// 删除线性表中指定索引位置的元素
// param0.线性表指针
// param1.索引
void listRemove(LinearList* list, int index);

#pragma mark - 改
// 修改线性表中指定位置的元素为指定的值
// param0.线性表指针
// param1.索引
// param2.值
void listSet(LinearList* list, int index, LinearListNodeValue value);

#pragma mark - 查
// 获取线性表指定索引处元素的值
// param0.线性表指针
// param1.索引
// return.元素的值
LinearListNodeValue listGet(LinearList* list, int index);

#pragma mark - 特殊功能
// 删除线性表中具有指定值的所有元素
// param0.线性表指针
// param1.要删除的值
void listRemoveValue_1(LinearList* list, LinearListNodeValue value);

// 删除线性表中具有指定值的所有元素
// param0.线性表指针
// param1.要删除的值
void listRemoveValue_2(LinearList* list, LinearListNodeValue value);

// 打印线性表
// param0.线性表指针
void listPrint(LinearList* list);

#endif /* LinearList_h */

HCGLinearList.c 文件，相对于上面的代码，做了三处更改：

头文件处 #include
listCreat(int capacity) 函数 capacity 为 0 时，不申请堆空间
listInsert(LinearList* list, int index, LinearListNodeValue value) 函数添加了扩容的代码

#pragma mark - 定义线性表结构体

// 数据节点指针
typedef void* LinearListNodeValue;

// 线性表结构体
typedef struct {
    int capacity;               // 容量
    int length;                 // 长度
    LinearListNodeValue* value; // 节点数据的指针(相当于 void** value，指向指针的指针)
} LinearList;

/*
 注意：宏 LINEARLIST_STRUCT 的定义，一定要在导入 HCGLinearList.h 之前
 这是为了防止上面的 LinearListNodeValue 指针和 LinearList 结构体被重复定义
 **/
//
#define LINEARLIST_STRUCT

#pragma mark - 导入头文件
#include "HCGLinearList.h"

// 使用 mallc函数 需要导入
#include 

// 使用内存拷贝函数 memcpy 需要导入
#include 

#pragma mark - 创建 销毁 清空
// 创建线性表
LinearList* listCreat(int capacity) {
    if (capacity < 0) {
        return NULL;
    }
    // 分配线性表结构体的内存空间（在堆区）
    // malloc函数如果遇到内存资源紧张，给不了这么多字节，可能会返回空
    LinearList* list = malloc(sizeof(LinearList));
    if (list) {
        list->capacity = capacity;
        list->length = 0;
        // 分配存储线性表元素的内存空间
        list->value = (list->capacity == 0 ? NULL : malloc(capacity * sizeof(LinearListNodeValue)));
        if (!list->value) {
            return NULL;
        }
    }
    return list;;
}

// 销毁线性表
void listRelease(LinearList* list) {
    if (NULL == list) {
        return;
    }
    if (list->value) {
        free(list->value);
    }
    free(list);
}

// 清空线性表
void listClear(LinearList* list) {
    if (NULL == list) {
        return;
    }
    // 这里不需要对线性表中的元素都置0
    // 只要将线性表的长度置为0，下次使用线性表的时候，就会对之前的数据进行覆盖了
    list->length = 0;
}

#pragma mark - 属性获取
// 获取线性表的长度
int listLength(LinearList* list) {
    if (NULL == list) {
        return 0;
    }
    return list->length;
}

// 获取线性表容量
int listCapacity(LinearList* list) {
    if (NULL == list) {
        return 0;
    }
    return list->capacity;
}

#pragma mark - 增
// 往线性表中插入数据
void listInsert(LinearList* list, int index, LinearListNodeValue value) {
    if (NULL == list) {
        return;
    }
    // 可以在表尾进行插入，因此这里的条件是 index > list->length，而不是 index >= list->length
    if (index < 0 || index > list->length) {
        return;
    }
    
    // 判断是否需要扩容
    if (list->length == list->capacity) {
        // 1.申请新的堆空间
        int tempCapacity = list->capacity + 10;
        LinearListNodeValue* tempValue = malloc(sizeof(LinearListNodeValue) * tempCapacity);
        if (NULL == tempValue) {
            return;
        }
        // 2.将旧的堆空间的数据 复制到 新的堆空间
        /*
        for (int i = 0; i < list->capacity; i++) {
            tempValue[i] = list->value[i];
        }
        */
        // param0.目标地址
        // param1.来源地址
        // param2.要拷贝的字节数
        memcpy(tempValue, list->value, sizeof(LinearListNodeValue) * list->capacity);
        // 3.释放旧的堆空间
        free(list->value);
        list->value = tempValue;
        // 4.修改capacity
        list->capacity = tempCapacity;
    }
    
    // 反向for循环挪动数据：从表尾数据开始挪动直到index标识的位置，每个数据依次向后挪动一个步长
    for (int i = list->length - 1; i >= index; i--) {
        list->value[i + 1] = list->value[i];
    }
    // 将新值value插入到index的位置
    list->value[index] = value;
    // 线性表的长度 + 1
    list->length++;
}

// 往线性表中添加数据（添加在表尾）
void listAdd(LinearList* list, LinearListNodeValue value) {
    if (NULL == list) {
        return;
    }
    listInsert(list, list->length, value);
}

#pragma mark - 删
// 删除线性表中指定索引位置的元素
void listRemove(LinearList* list, int index) {
    if (NULL == list) {
        return;
    }
    if (index < 0 || index > list->length - 1) {
        return;
    }
    // 反向for循环挪动数据：从(index + 1)标识的位置开始直到表尾，每个数据依次向前挪动一个步长
    for (int i = index + 1; i < list->length; i++) {
        list->value[i - 1] = list->value[i];
    }
    /*
    // 等效写法
    for (int i = index; i < list->length - 1; i++) {
        list->value[i] = list->value[i + 1];
    }
    */
    // 线性表的长度 - 1
    list->length--;
}

#pragma mark - 改
// 修改线性表中指定位置的元素为指定的值
void listSet(LinearList* list, int index, LinearListNodeValue value) {
    if (NULL == list) {
        return;
    }
    if (index < 0 || index > list->length - 1) {
        return;
    }
    list->value[index] = value;
}

#pragma mark - 查
// 获取线性表指定索引处元素的值
LinearListNodeValue listGet(LinearList* list, int index) {
    if (NULL == list) {
        return 0;
    }
    if (index < 0 || index > list->length - 1) {
        return 0;
    }
    return list->value[index];
}

#pragma mark - 特殊功能
// 删除线性表中具有指定值的所有元素 - 代码简单，但是效率低（时间复杂度高）
void listRemoveValue_1(LinearList* list, LinearListNodeValue value) {
    if (NULL == list) {
        return;
    }
    // 遍历所有元素
    for (int i = 0; i <= list->length - 1; i++) {
        while (list->value[i] == value && i <= list->length - 1) {
            listRemove(list, i);
        }
    }
}

// 删除线性表中具有指定值的所有元素 - 效率较高
void listRemoveValue_2(LinearList* list, LinearListNodeValue value) {
    if (NULL == list) {
        return;
    }
    // 遍历所有元素
    int removeCount = 0;
    for (int i = 0; i <= list->length - 1; i++) {
        if (list->value[i] == value) {
            removeCount++;
        } else {
            list->value[i - removeCount] = list->value[i];
        }
    }
    // 将长度减去删除的个数
    list->length -= removeCount;
}

// 打印线性表
void listPrint(LinearList* list) {
    if (NULL == list) {
        return;
    }
    printf("list{\n");
    printf("\tlength = %d;\n", list->length);
    printf("\tcapacity = %d;\n", list->capacity);
    printf("\tvalue = [");
    for (int i = 0; i <= list->length - 1; i++) {
        printf("%p", list->value[i]);
        if (i <= list->length - 2) {
            printf(",");
        }
    }
    printf("];\n\t}\n\n");
}

main.c 文件，测试 HCGLinearList 的扩容功能：

#import 
#import "HCGLinearList.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 创建线性表
        LinearList* list = listCreat(5);
        
        // 添加数据
        int total = 20;
        for (int i = 0; i < total; i++) {
            listAdd(list, (LinearListNodeValue)i);
            NSLog(@"list->length = %02d, list->value = %p", listLength(list), *((void**)list + 1));
        }
        
        // 打印
        listPrint(list);

        // 销毁线性表
        listRelease(list);
        list = NULL;
        
        /** 输出结果如下：
         list->length = 01, list->value = 0x10064b520
         list->length = 02, list->value = 0x10064b520
         list->length = 03, list->value = 0x10064b520
         list->length = 04, list->value = 0x10064b520
         list->length = 05, list->value = 0x10064b520
         list->length = 06, list->value = 0x100407b40
         list->length = 07, list->value = 0x100407b40
         list->length = 08, list->value = 0x100407b40
         list->length = 09, list->value = 0x100407b40
         list->length = 10, list->value = 0x100407b40
         list->length = 11, list->value = 0x100407b40
         list->length = 12, list->value = 0x100407b40
         list->length = 13, list->value = 0x100407b40
         list->length = 14, list->value = 0x100407b40
         list->length = 15, list->value = 0x100407b40
         list->length = 16, list->value = 0x100408d40
         list->length = 17, list->value = 0x100408d40
         list->length = 18, list->value = 0x100408d40
         list->length = 19, list->value = 0x100408d40
         list->length = 20, list->value = 0x100408d40
         list{
             length = 20;
             capacity = 25;
             value = [0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xa,0xb,0xc,0xd,0xe,0xf,0x10,0x11,0x12,0x13];
             }
         */
    }
    return 0;
}

你可能感兴趣的:(汇编基础)

基于STM32的简易RTOS分析-预备知识騏威嵌入式
写下这篇文章的主要目的是对自己学习RTOS的历程做一个记录和总结，方便以后回忆翻看。以下内容主要来自宋岩先生翻译的《Cortex-M3权威指南》。目录一、Cortex-M3寄存器简介二、堆栈操作简介三、汇编指令简介LDR和STR指令STMDB和LDMIA指令B、BX、BL、BLX指令MRS和MSR指令四、中断简介中断响应过程简介SVC和PensSV中断简介软件中断五、汇编基础一、Cortex-M3
栈和帧指针使用方法 greedyhao 反汇编栈帧
这篇主要是围绕SPFPPCLR寄存器进行介绍，不理解的可以一起讨论下，我也是今天才开始学习这些汇编基础知识处理器寄存器被指定为R0、R1等。MOVE指令的源位于左侧，目标位于右侧。伪处理程序中的堆栈从高地址增长到低地址。因此，push会导致堆栈指针的递减。pop会导致堆栈指针的增量。寄存器sp(stackpointer)用于指向堆栈。寄存器fp(framepointer)用作帧指针。帧指针充当被调
计算机基础1-汇编基础 unity学院苍狼王unity技术学院计算机常识操作汇编
汇编语言是一种低级的计算机语言，它直接与计算机硬件进行交互。在汇编语言中，指令由一系列助记符（mnemonic）组成，用于执行特定的操作，如数据传输、算术运算和控制流程等。每个指令都对应着一条机器码，这些机器码直接由计算机硬件执行。汇编语言的基本概念包括以下几个方面：寄存器：寄存器是计算机内部的一些特殊存储单元，用于存储数据和执行操作。常见的寄存器有通用寄存器（如AX、BX、CX等）、标志寄存器（
三. Cortex-A7简介 xuechw5 嵌入式ARM学习笔记 arm开发
Cortex-A7简介1.运行模型2.寄存器组3.汇编基础（1）汇编语法基本语句字段（2）数据传输指令（3）存储器访问指令（4）压栈和出栈指令（5）跳转指令（6）算数运算指令（7）逻辑运算指令1.运行模型九种运行模型：User、FIQ、IRQ、Supervisor(SVC)、Abort、Undef、Monitor、Hyp和System除了User(USR)用户模式以外，其它8种运行模式都是特权模式
6.Go语言学习笔记-结合chatGPT辅助学习Go语言底层原理爱因诗贤 golang 学习笔记
1、Go版本go1.14.152、汇编基础推荐阅读:GO汇编语言简介推荐阅读:AQuickGuidetoGo'sAssembler-TheGoProgrammingLanguage精简指令集数据传输:MOV/LEA跳转指令:CMP/TEST/JMP/JCC栈指令:PUSH/POP函数调用指令:CALL/RET算术指令:ADD/SUB/MUL/DIV逻辑指令:AND/OR/XOR/NOT移位指令:S
ARM汇编基础(iOS逆向) 编程怪才_凌雨画
ARM汇编基础在逆向一个功能的时候,往往需要分析大量的汇编代码,在iOS逆向中,ARM汇编是必须掌握的语言,本文总结了ARM汇编的基础知识,如果你想了解更多,请参考狗神的小黄书《iOS逆向逆向工程》或ARM官方手册.寄存器,内存和栈在ARM汇编里,操作对象是寄存器,内存和栈ARM的栈遵循先进后出,是满递减的,向下增长,也就是开口向下,新的变量被存到栈底的位置;越靠近栈底,内存地址越小一个名为sta
汇编基础知识六暴走竹竿
0x01简介这里开始熟悉汇编的指令格式X64dbg界面一下图为X86版本的指令格式，X64的指令格式和X86差不多后面有需要的话再详细写image中文版0x02IstructionPrefixes前缀指令IstructionPrefixes:可选项默认二进制文件是前缀和内容混杂在一起只有机器才能识别区别人工区分方法：逆向：debug工具打开程序前面有冒号的就是带前缀的操作指令示例前缀指令分组X86
C/C++安卓手游内存逆向、手游call教程（类人猿学院）类人猿学院 c语言 c++android
主要内容和方向：从C语言基础知识讲起；x86/x64/arm汇编基础、逆向手游内部数据、内存读写和call调用、内部hook；注入call框架编写；辅助控制界面和通讯；内部封包逆向数据分析。目前全网就我们能搞安卓手机、模拟器call分析和调用一套龙教程，学会基本是手游脚本辅助行业领先。欢迎各大逆向爱好者来学习和建议。编程语言：主要C语言，部分用C++或者易语言或者脚本语言第一套：C语言入门到进阶部
逆向P1P2总结小凡子空白在线学习逆向汇编
字节八位word16位deword32位000000e8是存储32位信息的起点不是程序运行的起点为什么电脑有32位与64位之分寻址宽度以字节为单位0xfffffff+1就是最大容量转为十进制为4294967296/1024（k）/1024（kb）/1024（m）4g不建议看了太卡了要有汇编基础
科锐16位汇编学习笔记01汇编基础和debug使用雪碧透心凉_ 科锐学习笔记汇编学习笔记
为什么学习16位汇编？16位操作指令最多能够操作两个字节，且更能够体现出与硬件的交互。16位下的指令和32位汇编的指令差不多。16位汇编的指令在32位一样使用.要学好汇编必须要了解一点点硬件知识,16汇编是直接操作硬件,32位汇编指令跟硬件隔离了硬件运行机制1.为什么计算机的操作数据的单位是二进制？字节是内存操作的最小单位,但是位才是计算机操作的最小单位•电子器件二极管•正向加电则通，反向加电则不
C/C++汇编学习（三）——指令集-汇编基础 Thomas_Lbw 汇编语言 c语言 c++汇编
汇编语言是一种用于与计算机硬件直接交互的低级编程语言。它非常接近机器语言，但提供了更易于理解的符号来表示机器指令和数据。不同的处理器架构有不同的汇编语言。例如，x86架构用于大多数个人电脑，而ARM架构常见于移动设备。目录1.指令集x86指令集1.数据处理指令2.数据传输指令3.控制流指令4.字符串和重复操作指令5.位操作指令6.特殊和系统指令7.SIMD指令ARM指令集1.数据处理指令2.数据传
03-汇编基础（3）深圳_你要的昵称
前言本篇文章主要讲解状态寄存器判断、选择和循环一、状态寄存器（CPSR）什么是状态寄存器？CPU内部的寄存器中，有一种特殊的寄存器(对于不同的处理器,个数和结构都可能不同)。这种寄存器在ARM中，被称为状态寄存器CPSR(currentprogramstatusregister)。与其它寄存区的区别其它寄存器是用来存放数据的，整个寄存器只具有一个含义。CPSR寄存器是按位起作用的，也就是说它的每一
裸机开发(1)-汇编基础 Embedded-Xin Linux驱动/内核编程汇编 linux 驱动开发
文章目录GNU汇编语法常用汇编指令处理器内部数据传输指令存储器访问指令压栈和出栈指令跳转指令算术指令逻辑运算指令实战函数发生调用时，需要进行线程保护，简单来说，就是先进行压栈操作，将调用函数参数、返回值等存到R0-15寄存器中，在执行完毕后，需要将数据内容从寄存器读出，进行出栈操作，而这一系列操作需要SP指针。芯片上电后SP指针（堆栈指针寄存器）还未初始化完毕，无法执行C代码，所以必须要用汇编设置
IDA PRO 0A - 交叉引用二手的程序员 IDA PRO java 开发语言前端
本文将讨论IDA中的交叉引用的相关知识。更多c++逆向知识可以看B站的课程《C++反汇编基础教程(IDAProVisualStudio)》交叉引用IDA中的交叉引用通常简称为xref。从名字可以看出，使用快捷键就可以找出某个函数或者数据被引用的地方。在IDA中有两类基本的交叉引用：代码交叉引用和数据交叉引用。这两种引用又分别包含几种不同的交叉引用。文本CODEXREF表示这是一个代码交叉引用，而非
ARM 汇编入门故事还在继续吗汇编 arm开发汇编
ARM汇编入门引言ARM汇编语言是ARM架构的汇编语言，用于直接控制ARM处理器。虽然现代软件开发更多地依赖于高级语言和编译器，但理解ARM汇编仍然对于深入了解系统、优化代码和进行低级调试非常重要。本文将为您提供一个简单的ARM汇编入门指南。1.ARM汇编基础1.1寄存器ARM架构有16个通用寄存器，分别命名为R0到R15。这些寄存器用于存储数据和地址。R0到R12：通用数据寄存器。R13：堆栈指
【嵌入式linux】如何学习嵌入式linux bdview 嵌入式内核编程语言 linux 人工智能
转----------作为一个新人，怎样学习嵌入式Linux？(2012-4-1923:48)作为一个新人，怎样学习嵌入式Linux？被问过太多次，特写这篇文章来回答一下。在学习嵌入式Linux之前，肯定要有C语言基础。汇编基础有没有无所谓(就那么几条汇编指令，用到了一看就会)。C语言要学到什么程度呢？越熟当然越好，不熟的话也要具备基本技能。比如写一个数组排序、输入数字求和什么的。学C语言唯一的方
Linux环境下ARM开发别问，问就是全会嵌入式系统 linux arm开发
目录前言ARM启动及开发基础1.Cortex-A架构2.启动方式3.汇编基础4.Makefile语法基础5.Makefile补充6.编译下载结语前言主要介绍基于linux开发环境下，如何开发ARMA7ARM启动及开发基础1.Cortex-A架构1）Cortex-A7运行模式模式说明User(USR)用户模式，非特权模式，大部分程序运行的时候就处于此模式。FIQ快速中断模式，进入FIQ中断异常I
iOS 逆向开发01：ARM汇编基础 differ_iOSER
iOS逆向开发文章汇总目录一、汇编语言的发展机器语言、汇编语言、高级语言、汇编语言的特点、汇编的用途、汇编语言的种类、几个必要的常识二、总线三、内存四、进制进制的定义、练习、进制的运算五、数据的宽度六、CPU&寄存器七、常见寄存器浮点和向量寄存器、通用寄存器、pc寄存器、高速缓存、bl指令、OC汇编混编初识汇编我们在前期的学习中，了解到在逆向开发中，非常重要的一个环节就是静态分析.首先我们是逆向i
启xin宝app的token算法破解——逆向篇（二）吾爱小白
启xin宝app的token算法破解——抓包分析篇（一）文章已经对该app进行了抓包分析，现在继续对它进行逆向。对于一个app而言，我们要逆向app，需要知道什么呢？逆向工具Java基础，甚至c和汇编基础加固类型和脱壳工具安卓开发基础对安卓系统的认知对xposed的认知smali基础以上这些是必须了解甚至掌握的，爬虫逆向路上越走越远了。回归正题，该app是怎样一种app呢？？如何去查看app是否加
ARM 汇编基础我来挖坑啦 arm开发汇编
我们在学习STM32的时候几乎没有用到过汇编，可能在学习UCOS、FreeRTOS等RTOS类操作系统移植的时候可能会接触到一点汇编。但是我们在进行嵌入式Linux开发的时候是绝对要掌握基本的ARM汇编，因为Cortex-A芯片一上电SP指针还没初始化，C环境还没准备好，所以肯定不能运行C代码，必须先用汇编语言设置好C环境，比如初始化DDR、设置SP指针等等，当汇编把C环境设置好了以后才可以运行C
iOS逆向之汇编基础知识(二) sinat_36214015 iOS 逆向底层原理汇编基础 swift
#本人有若干成套学习视频,可试看!可试看!可试看,重要的事情说三遍包含Java,数据结构与算法,iOS,安卓,python,flutter等等,如有需要,联系微信tsaievan.####(一)程序的本质让我们来看一副图,看看程序的本质是什么:#####通常,CPU会先将内存中的数据存储到寄存器中,然后再对寄存器中的数据进行运算#####假设内存中有块红色内存空间的值是3,现在想把它的值加1,并将
汇编基础知识嵌入式男孩菜鸟开始学汇编汇编
1.1机器语言机器语言就是一些二进制代码，存放在内存中。它是机器指令的集合，所谓机器指令就是机器能够正确执行的命令1.2汇编语言的产生1.汇编语言的主体是汇编指令2.汇编指令实际上就是机器指令的助记符。它们的唯一区别在于书写方式上寄存器：CPU中可以存储数据的器件，一个CPU可以有多个存储器编译过程：1.3汇编语言的组成汇编语言主要由汇编指令（机器码的助记符），伪指令（由编译器执行），其他符号（由
庖丁解牛Linux内核分析01：操作系统工作原理基础麦兜的学习笔记 Linux内核源码分析 Linux内核
目录1存储程序计算机工作模型2IA-32汇编基础2.1寄存器概述2.1.1通用寄存器2.1.2段寄存器2.1.3标志寄存器2.2数据格式2.3寻址方式2.3.1立即数寻址2.3.2寄存器寻址2.3.3存储器引用寻址2.4内嵌汇编概述2.4.1内嵌汇编简单语法2.4.2内嵌汇编示例3深入理解函数调用栈3.1相关寄存器3.2相关指令3.2.1pushl&popl指令3.2.2call&ret指令3.3
20135327郭皓——信息安全系统设计基础第五周学习总结 angle4276 c/c++数据结构与算法操作系统
第五周（10.05-10.11）:学习计时：共5小时读书：代码：作业：博客：一、学习目标1.理解逆向的概念以及2.掌握X86汇编基础，能够阅读（反）汇编代码3.了解ISA（指令集体系结构）4.理解函数调用栈帧的概念，并能用GDB进行调试第三章程序的机器级表示3.1历史观点Inter处理器俗称x863.2程序编码gcc编译器编译流程：·C预处理器扩展源代码；·编译器产生两个源代码的汇编代码p1.sp
Orange‘s：一个操作系统的实现学习笔记2 超大青花鱼学习
第三章第一节代码运行实录前言代码实现了什么操作流程代码+注释运行效果一些问题1.段描述符的结构2.段选择子的结构3.地址转换4.GDTR的结构5.打开A20地址线6.CR0寄存器的结构7."$"前言去年就开始学习Orange’s：一个操作系统的实现，今年记录并总结一下学习中遇到的一些问题，由于我汇编基础几乎为0，对计算机也不是很了解，所以写的这些注释和总结难免会有错误和纰漏，敬请原谅。此篇笔记抄的
红队专题-REVERSE二进制逆向反编译 amingMM 软件工程
红队专题招募六边形战士队员逆向基础EIP1.1汇编基础x86寄存器ARM寄存器X86和ARM的汇编指令总论1.2常用逆向思路1.3工具1.3.1二进制编辑器1.3.2可执行文件查看工具1.3.3格式转换工具x64dbg2020.06.04反汇编修改神器x64dbg调试器主要分为三部分载体：x64dbg初步认知快捷键IDApro安装python2加入环境变量py2安装pip安装IDA7.0proID
如何编写游戏辅助工具技术宅也爱玩游戏 pygame python
一、先说一下写一个游戏辅助工具需要什么条件1、熟练的C语言知识目前的游戏辅助工具大部分都是用BC或者是vc写的，拥有熟练的C语言知识是写游戏辅助工具的基本条件2、具有很强的汇编基础一般游戏都不可能有原代码的，必须靠反汇编或者跟踪的办法来探索其中的机理，所以有强的汇编基础也是必不可少的条件3、熟练掌握跟踪和调试的工具有了上面2个条件后，掌握一些工具也是很有必要的跟踪的工具，softice当然是不二之
作为一个新人，怎样学习嵌入式Linux？嵌入式开发白菜编程嵌入式学习笔记 java 人工智能嵌入式硬件
在学习嵌入式Linux之前，肯定要有C语言基础。汇编基础有没有无所谓(就那么几条汇编指令，用到了一看就会)。C语言要学到什么程度呢？越熟当然越好，不熟的话也要具备基本技能。比如写一个数组排序、输入数字求和什么的。学C语言唯一的方法是多写程序多练习，编译出错没关系，自己去解决；执行出错没关系，自己去分析。以前我是用VC来练习C语言的，经常去尝试着写一些C语言竞赛的题目。它们是纯C、纯数学、纯逻辑的题
汇编基础知识五暴走竹竿
0x01and和or指令and逻辑"与"运算，按位运算都一为一例:moval,01100011Bandal,00111011B执行后al=00100011Bor逻辑"或"运算，有一为一例:moval,01100011Boral,00111011B执行后al=01111011B0x02字符串形式汇编中的字符串有两种字符串形式用引号方式包围的字符串例moval,'helloworld用ASCII码输入
汇编基础学习 coldfresh 编程语言
assumecs:code,ds:datadatasegmentdb'welcometomasm!'db02h,24h,71hdataendsstacksegmentstackdw8dup(0)stackendscodesegmentstart:movax,datamovds,axmovax,stackmovss,axmovsp,10hxorbx,bxmovax,0b872hmovcx,3s3:p
java杨辉三角 3213213333332132 java基础
package com.algorithm; /** * @Description 杨辉三角 * @author FuJianyong * 2015-1-22上午10:10:59 */ public class YangHui { public static void main(String[] args) { //初始化二维数组长度 int[][] y
《大话重构》之大布局的辛酸历史白糖_ 重构
《大话重构》中提到“大布局你伤不起”，如果企图重构一个陈旧的大型系统是有非常大的风险，重构不是想象中那么简单。我目前所在公司正好对产品做了一次“大布局重构”，下面我就分享这个“大布局”项目经验给大家。背景公司专注于企业级管理产品软件，企业有大中小之分，在2000年初公司用JSP/Servlet开发了一套针对中
电驴链接在线视频播放源码 dubinwei 源码电驴播放器视频 ed2k
本项目是个搜索电驴（ed2k）链接的应用,借助于磁力视频播放器（官网： http://loveandroid.duapp.com/ 开放平台），可以实现在线播放视频，也可以用迅雷或者其他下载工具下载。项目源码： http://git.oschina.net/svo/Emule,动态更新。也可从附件中下载。项目源码依赖于两个库项目，库项目一链接： http://git.oschina.
Javascript中函数的toString()方法周凡杨 JavaScript js toString function object
简述 The toString() method returns a string representing the source code of the function. 简译之，Javascript的toString()方法返回一个代表函数源代码的字符串。句法 function.
struts处理自定义异常 g21121 struts
很多时候我们会用到自定义异常来表示特定的错误情况，自定义异常比较简单，只要分清是运行时异常还是非运行时异常即可，运行时异常不需要捕获，继承自RuntimeException，是由容器自己抛出，例如空指针异常。非运行时异常继承自Exception，在抛出后需要捕获，例如文件未找到异常。此处我们用的是非运行时异常，首先定义一个异常LoginException: /** * 类描述：登录相
Linux中find常见用法示例 510888780 linux
Linux中find常见用法示例 ·find path -option [ -print ] [ -exec -ok command ] {} \; find命令的参数；
SpringMVC的各种参数绑定方式 Harry642 springMVC 绑定表单
1. 基本数据类型(以int为例，其他类似)： Controller代码： @RequestMapping("saysth.do") public void test(int count) { } 表单代码： <form action="saysth.do" method="post&q
Java 获取Oracle ROWID aijuans java oracle
A ROWID is an identification tag unique for each row of an Oracle Database table. The ROWID can be thought of as a virtual column, containing the ID for each row. The oracle.sql.ROWID class i
java获取方法的参数名 antlove java jdk parameter method reflect
reflect.ClassInformationUtil.java package reflect; import javassist.ClassPool; import javassist.CtClass; import javassist.CtMethod; import javassist.Modifier; import javassist.bytecode.CodeAtt
JAVA正则表达式匹配查找替换提取操作百合不是茶 java 正则表达式替换提取查找
正则表达式的查找;主要是用到String类中的split(); String str; str.split();方法中传入按照什么规则截取,返回一个String数组常见的截取规则: str.split("\\.")按照.来截取 str.
Java中equals()与hashCode()方法详解 bijian1013 java set equals()hashCode()
一.equals()方法详解 equals()方法在object类中定义如下： public boolean equals(Object obj) { return (this == obj); } 很明显是对两个对象的地址值进行的比较（即比较引用是否相同）。但是我们知道，String 、Math、I
精通Oracle10编程SQL(4)使用SQL语句 bijian1013 oracle 数据库 plsql
--工资级别表 create table SALGRADE ( GRADE NUMBER(10), LOSAL NUMBER(10,2), HISAL NUMBER(10,2) ) insert into SALGRADE values(1,0,100); insert into SALGRADE values(2,100,200); inser
【Nginx二】Nginx作为静态文件HTTP服务器 bit1129 HTTP服务器
Nginx作为静态文件HTTP服务器在本地系统中创建/data/www目录，存放html文件(包括index.html) 创建/data/images目录，存放imags图片在主配置文件中添加http指令 http { server { listen 80; server_name
kafka获得最新partition offset blackproof kafka partition offset 最新
kafka获得partition下标，需要用到kafka的simpleconsumer import java.util.ArrayList; import java.util.Collections; import java.util.Date; import java.util.HashMap; import java.util.List; import java.
centos 7安装docker两种方式 ronin47
第一种是采用yum 方式 yum install -y docker
java-60-在O(1)时间删除链表结点 bylijinnan java
public class DeleteNode_O1_Time { /** * Q 60 在O(1)时间删除链表结点 * 给定链表的头指针和一个结点指针(!!)，在O(1)时间删除该结点 * * Assume the list is: * head->...->nodeToDelete->mNode->nNode->..
nginx利用proxy_cache来缓存文件 cfyme cache
user zhangy users; worker_processes 10; error_log /var/vlogs/nginx_error.log crit; pid /var/vlogs/nginx.pid; #Specifies the value for ma
[JWFD开源工作流]JWFD嵌入式语法分析器负号的使用问题 comsci 嵌入式
假如我们需要用JWFD的语法分析模块定义一个带负号的方程式，直接在方程式之前添加负号是不正确的，而必须这样做： string str01 = "a=3.14;b=2.71;c=0;c-((a*a)+(b*b))" 定义一个0整数c,然后用这个整数c去
如何集成支付宝官方文档 dai_lm android
官方文档下载地址 https://b.alipay.com/order/productDetail.htm?productId=2012120700377310&tabId=4#ps-tabinfo-hash 集成的必要条件 1. 需要有自己的Server接收支付宝的消息 2. 需要先制作app，然后提交支付宝审核，通过后才能集成调试的时候估计会真的扣款，请注意
应该在什么时候使用Hadoop datamachine hadoop
原帖地址：http://blog.chinaunix.net/uid-301743-id-3925358.html 存档，某些观点与我不谋而合，过度技术化不可取，且hadoop并非万能。 --------------------------------------------万能的分割线-------------------------------- 有人问我，“你在大数据和Hado
在GridView中对于有外键的字段使用关联模型进行搜索和排序 dcj3sjt126com yii
在GridView中使用关联模型进行搜索和排序首先我们有两个模型它们直接有关联: class Author extends CActiveRecord { ... } class Post extends CActiveRecord { ... function relations() { return array( '
使用NSString 的格式化大全 dcj3sjt126com Objective-C
格式定义The format specifiers supported by the NSString formatting methods and CFString formatting functions follow the IEEE printf specification; the specifiers are summarized in Table 1. Note that you c
使用activeX插件对象object滚动有重影蕃薯耀 activeX插件滚动有重影
使用activeX插件对象object滚动有重影 <object style="width:0;" id="abc" classid="CLSID:D3E3970F-2927-9680-BBB4-5D0889909DF6" codebase="activex/OAX339.CAB#
SpringMVC4零配置 hanqunfeng springmvc4
基于Servlet3.0规范和SpringMVC4注解式配置方式，实现零xml配置，弄了个小demo，供交流讨论。项目说明如下： 1.db.sql是项目中用到的表，数据库使用的是oracle11g 2.该项目使用mvn进行管理，私服为自搭建nexus,项目只用到一个第三方 jar，就是oracle的驱动； 3.默认项目为零配置启动，如果需要更改启动方式，请
《开源框架那点事儿16》：缓存相关代码的演变 j2eetop 开源框架
问题引入上次我参与某个大型项目的优化工作，由于系统要求有比较高的TPS，因此就免不了要使用缓冲。该项目中用的缓冲比较多，有MemCache，有Redis，有的还需要提供二级缓冲，也就是说应用服务器这层也可以设置一些缓冲。当然去看相关实现代代码的时候，大致是下面的样子。 [java] view plain copy print ? public vo
AngularJS浅析 kvhur JavaScript
概念 AngularJS is a structural framework for dynamic web apps. 了解更多详情请见原文链接：http://www.gbtags.com/gb/share/5726.htm Directive 扩展html，给html添加声明语句，以便实现自己的需求。对于页面中html元素以ng为前缀的属性名称，ng是angular的命名空间
架构师之jdk的bug排查(一)---------------split的点号陷阱 nannan408 split
1.前言. jdk1.6的lang包的split方法是有bug的,它不能有效识别A.b.c这种类型,导致截取长度始终是0.而对于其他字符,则无此问题.不知道官方有没有修复这个bug. 2.代码 String[] paths = "object.object2.prop11".split("'"); System.ou
如何对10亿数据量级的mongoDB作高效的全表扫描 quentinXXZ mongodb
本文链接: http://quentinXXZ.iteye.com/blog/2149440 一、正常情况下，不应该有这种需求首先，大家应该有个概念，标题中的这个问题，在大多情况下是一个伪命题，不应该被提出来。要知道，对于一般较大数据量的数据库，全表查询，这种操作一般情况下是不应该出现的，在做正常查询的时候，如果是范围查询，你至少应该要加上limit。说一下，
C语言算法之水仙花数 qiufeihu c 算法
/** * 水仙花数 */ #include <stdio.h> #define N 10 int main() { int x,y,z; for(x=1;x<=N;x++) for(y=0;y<=N;y++) for(z=0;z<=N;z++) if(x*100+y*10+z == x*x*x
JSP指令 wyzuomumu jsp
jsp指令的一般语法格式： <%@ 指令名属性 =”值 ” %> 常用的三种指令： page,include,taglib page指令语法形式： <%@ page 属性 1=”值 1” 属性 2=”值 2”%> include指令语法形式： <%@include file=”relative url”%> (jsp可以通过 include