首先 先写个一个读取文件的方法
char* Read_File(string file_Path) {
    filebuf *pbuf;
    ifstream filestr;
    long size;
    char *buffer;
    // 要读入整个文件，必须采用二进制打开
    filestr.open(file_Path, ios::binary);
    // 获取filestr对应buffer对象的指针
    pbuf = filestr.rdbuf();

    // 调用buffer对象方法获取文件大小
    size = pbuf->pubseekoff(0, ios::end, ios::in);
    pbuf->pubseekpos(0, ios::in);

    // 分配内存空间
    buffer = new char[size];

    // 获取文件内容
    pbuf->sgetn(buffer, size);

    filestr.close();
    // 输出到标准输出
    //cout.write (buffer,size);

    // delete []buffer;
    return buffer;
}

main:    
//得到文件内存地址指针
    char* fp = Read_File("/home/zlq/baidunetdiskdownload/android/classes.dex");
      //强转为DexFile指针
    DexFile *dex = (DexFile*)&fp;
    //解析struct header_item dex_header
    Read_DexHeader(dex->pHeader);

/**
 * 实现方法
 * @param dexHeader
 */
void Read_DexHeader(DexHeader* dexHeader)
{
    //struct header_item dex_header

    printf("struct header_item dex_header\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t0x0");
    printf("\t\t\t\t0x%x", (unsigned int)sizeof(DexHeader));
    printf("\t\tDEX 文件头，记录了一些当前文件的信息以及其他数据结构在文件中的偏移量");
    printf("\n\tmagic\t\t\t\t\t\t\t\t");
    char* magic = (char*)dexHeader->magic;
    while(*magic != '\0')
    {
        if(*magic != '\n')
        {
            printf("%c ",(*magic));
        }
        magic++;
    }
    printf("\t\t\t\t\t\t\t\t\t\t0x0\t\t\t\t0x%x\t\t\t取值必须是字符串 \"dex\\n035\\0\" 或者字节byte数组 {0x64 0x65 0x78 0x0a 0x30 0x33 0x35 0x00}",
            (unsigned int)sizeof(dexHeader->magic));
    printf("\n\tchecksum\t\t\t\t\t\t\t0x%X\t\t\t\t\t\t\t\t\t\t\t0x%x\t\t\t\t0x%x\t\t\t文件内容的校验和,不包括magic和自己,主要用于检查文件是否损坏"
            ,dexHeader->checksum
            ,(unsigned int)sizeof(dexHeader->magic)
            ,(unsigned int)sizeof(dexHeader->checksum));
    .... 略

DexStringId*  pStringIds;     //数组,元素类型为string_id_item,存储字符串相关的信息

其中一部分的输出:

010:

总结:

 *      dex->pHeader->stringIdsOff 存储了整个dex的字符串的偏移的首地址 是一个数组类型
 *      dex->pHeader->stringIdsSize 存储字符串的个数
 *      字符串偏移指向的地址的内容通过 readUnsignedLeb128 解码  字符串的长度通过判断'\0' 即可 

DexTypeId*    pTypeIds;       //数组,存储类型相关的信息

/*
 * Direct-mapped "type_id_item".
 */
struct DexTypeId {
    u4  descriptorIdx;      /* 指向string_ids的索引 */
};

void Read_DexTypeId(char* fp)
{
    DexFile *dex = (DexFile*)&fp;
    printf("\n\nstruct struct type_id_list dex_type_ids\t%d\t\t\t\t\t\t\t\t\t\t\t\t0x%x", dex->pHeader->typeIdsSize,(unsigned int) sizeof(DexHeader));
    printf("\t\t\t0x%x", (unsigned int) sizeof(DexTypeId));
    printf("\t\t\t数组,存储类型相关的信息\n");
    //拿到类型的偏移
    int *typeIdsOff = (int*)(fp + dex->pHeader->typeIdsOff);
    for (int i = 0; i < dex->pHeader->typeIdsSize; ++i) {
        printf("\n\tstruct type_id_list dex_type_ids[%d]:",i);
        //先拿到字符串的偏移
        int *stringIdsOff = (int*)(fp + dex->pHeader->stringIdsOff);
        //再根据类型的偏移去寻找字符串
        const u1* stringdata = (u1*)fp+stringIdsOff[(*typeIdsOff)];
        //解码
        readUnsignedLeb128(&stringdata);
        while(*stringdata != '\0')
        {
            printf("%c",(*stringdata));
            stringdata++;
        }
        //自加 获取下一个指针  int型指针自加 base += 1
        typeIdsOff++;
    }
}

DexFieldId*   pFieldIds;      //数组,存储成员变量信息,包括变量名和类型等

具体结构:

struct DexFieldId {
    u2  classIdx;           /* field所属的class类型，class_idx的值时type_ids的一个index，指向所属的类 */
    u2  typeIdx;            /* field的类型，值是type_ids的一个index */
    u4  nameIdx;            /* field的名称，它的值是string_ids的一个index */
};

void Read_DexFieldId(char* fp)
{
    DexFile *dex = (DexFile*)&fp;
    printf("\n\nstruct field_id_list dex_field_ids\t%d\t\t\t\t\t\t\t\t\t\t\t\t0x%x", dex->pHeader->fieldIdsSize,(unsigned int) sizeof(DexHeader));
    printf("\t\t\t0x%x", (unsigned int) sizeof(DexFieldId));
    printf("\t\t\t数组,存储类的相关的信息");
    //转为DexFieldId结构体
    DexFieldId *dexFieldId = (DexFieldId*)(fp + dex->pHeader->fieldIdsOff);
    for (int i = 0; i < dex->pHeader->fieldIdsSize; ++i) {
        printf("\n\tstruct field_id_item field_id[%d]",i);

        /**
         * 重点:
         *      要想找到field_id的typeIdx对应位置的值 要先找到 typeIdsOff偏移地址+typeIdx等于string_ids的索引,再通过string_ids来寻找值
         *
         *      [类型偏移首地址+typeIdx索引] = 字符串所在的索引位置
         *      字符串偏移首地址[字符串所在的索引位置] =  [类型偏移首地址+typeIdx索引]的具体值
         */
        //拿到类型的偏移首地址
        int *typeIdsOff = (int*)(fp + dex->pHeader->typeIdsOff);
        //拿到字符串的偏移首地址
        int *stringIdsOff = (int*)(fp + dex->pHeader->stringIdsOff);
        //类型偏移地址+索引=字符串索引
        //字符串偏移+字符串索引=typeIdx位置具体的值
        const u1* typeIdx_stringdata = (u1*)fp+stringIdsOff[(*(typeIdsOff+dexFieldId->typeIdx))];
        //解码
        readUnsignedLeb128(&typeIdx_stringdata);
        printf("\n\t\ttypeIdx --> ");
        while(*typeIdx_stringdata != '\0')
        {
            printf("%c",(*typeIdx_stringdata));
            typeIdx_stringdata++;
        }



        //u2  classIdx;           /* field所属的class类型，class_idx的值时type_ids的一个index，指向所属的类 */
        const u1* classIdx_stringdata = (u1*)fp+stringIdsOff[(*(typeIdsOff+dexFieldId->classIdx))];
        //解码
        readUnsignedLeb128(&classIdx_stringdata);
        printf("\n\t\tclassIdx--> ");
        while(*classIdx_stringdata != '\0')
        {
            printf("%c",(*classIdx_stringdata));
            classIdx_stringdata++;
        }


        //u4  nameIdx;            /* field的名称，它的值是string_ids的一个index */
        const u1* nameIdx_stringdata = (u1*)fp+stringIdsOff[(dexFieldId->nameIdx)];
        //解码
        readUnsignedLeb128(&nameIdx_stringdata);
        printf("\n\t\tnameIdx --> ");
        while(*nameIdx_stringdata != '\0')
        {
            printf("%c",(*nameIdx_stringdata));
            nameIdx_stringdata++;
        }
        dexFieldId++;
    }
}

struct DexMethodId {
    u2  classIdx;           /* method所属的class类型，class_idx的值是type_ids的一个index，必须指向一个class类型 */
    u2  protoIdx;           /* method的原型，指向proto_ids的一个index */
    u4  nameIdx;            /* method的名称，值为string_ids的一个index */
};

void Read_DexProtoId(char* fp)
{
    
    DexFile *dex = (DexFile*)&fp;
    printf("\n\nstruct proto_id_list dex_proto_ids\t%d\t\t\t\t\t\t\t\t\t\t\t\t0x%x", dex->pHeader->protoIdsSize,(unsigned int) sizeof(DexHeader));
    printf("\t\t\t0x%x", (unsigned int) sizeof(DexMethodId));
    printf("\t\t\t数组,函数原型数据索引，记录了方法声明的字符串，返回类型和参数列表");
    //转为DexMethodId结构体
    DexProtoId *dexProtoId = (DexProtoId*)(fp + dex->pHeader->protoIdsOff);
    for (int i = 0; i < dex->pHeader->protoIdsSize; ++i) {
        printf("\n\tstruct proto_id_item proto_id[%d]", i);
        int *typeIdsOff = (int*)(fp + dex->pHeader->typeIdsOff);
        int *stringIdsOff = (int*)(fp + dex->pHeader->stringIdsOff);
        const u1* shortyIdx_stringdata = (u1*)fp+stringIdsOff[dexProtoId->shortyIdx];
        //解码
        readUnsignedLeb128(&shortyIdx_stringdata);
        printf("\n\t\tshortyIdx--> ");
        while(*shortyIdx_stringdata != '\0')
        {
            printf("%c",(*shortyIdx_stringdata));
            shortyIdx_stringdata++;
        }

        const u1* returnTypeIdx_stringdata = (u1*)fp+stringIdsOff[(*(typeIdsOff+dexProtoId->returnTypeIdx))];
        readUnsignedLeb128(&returnTypeIdx_stringdata);
        printf("\n\t\tprotoIdx--> ");
        while(*returnTypeIdx_stringdata != '\0')
        {
            printf("%c",(*returnTypeIdx_stringdata));
            returnTypeIdx_stringdata++;
        }

        printf("\n\t\tparametersOff--> %d",dexProtoId->parametersOff);

        dexProtoId++;
    }
}

DexClassDef*  pClassDefs;     //数组,存储类的信息

结构体

struct DexClassDef {
    u4  classIdx;           /* 描述具体的class类型，值是type_ids的一个index，值必须是一个class类型，不能是数组或者基本类型 */
    u4  accessFlags;        /* 描述class的访问类型，如public,final,static等 */
    u4  superclassIdx;      /* 描述父类的类型，值必须是一个class类型，不能是数组雷兴国或者基本类型 */
    u4  interfacesOff;      /* 值为偏移地址，被指向的数据结构为type_list，class若没有interfaces，值为0 */
    u4  sourceFileIdx;      /* 表示源代码文件的信息，值为string_ids的一个index。若此项信息丢失，此项赋值为NO_INDEX=0xFFFFFFFF */
    u4  annotationsOff;     /* 值为偏移地址，指向的内容是该class的注解，位置在data区，格式为annotations_directory_item，若没有此项，值为0 */
    u4  classDataOff;       /* 值为偏移地址，指向的内容是该class的使用到的数据，位置在data区，格式为class_data_item。无偶没有此项，则值为0 */
    u4  staticValuesOff;    /* 值为偏移地址，指向data区里的一个列表，格式为encoded_array_item。若没有此项，值为0. */
};

void Read_DexClassDef(char* fp)
{
    //u4  classIdx;           /* 描述具体的class类型，值是type_ids的一个index，值必须是一个class类型，不能是数组或者基本类型 */
    //u4  accessFlags;        /* 描述class的访问类型，如public,final,static等 */
    //u4  superclassIdx;      /* 描述父类的类型，值必须是一个class类型，不能是数组或者基本类型 */
    //u4  interfacesOff;      /* 值为偏移地址，被指向的数据结构为type_list，class若没有interfaces，值为0 */
    //u4  sourceFileIdx;      /* 表示源代码文件的信息，值为string_ids的一个index。若此项信息丢失，此项赋值为NO_INDEX=0xFFFFFFFF */
    //u4  annotationsOff;     /* 值为偏移地址，指向的内容是该class的注解，位置在data区，格式为annotations_directory_item，若没有此项，值为0 */
    //u4  classDataOff;       /* 值为偏移地址，指向的内容是该class的使用到的数据，位置在data区，格式为class_data_item。无偶没有此项，则值为0 */
    //u4  staticValuesOff;    /* 值为偏移地址，指向data区里的一个列表，格式为encoded_array_item。若没有此项，值为0. */

    DexFile *dex = (DexFile*)&fp;
    printf("\n\nstruct class_def_item_list dex_class_defs\t%d\t\t\t\t\t\t\t\t\t\t\t\t0x%x", dex->pHeader->classDefsSize,(unsigned int) sizeof(DexHeader));
    printf("\t\t\t0x%x", (unsigned int) sizeof(DexMethodId));
    printf("\t\t\t数组,存储类的信息");
    //转为DexMethodId结构体
    DexClassDef *dexClassDef = (DexClassDef*)(fp + dex->pHeader->classDefsOff);
    for (int i = 0; i < dex->pHeader->classDefsSize; ++i) {
        printf("\n\tstruct class_def_item class_def[%d]", i);
        int *typeIdsOff = (int*)(fp + dex->pHeader->typeIdsOff);
        int *stringIdsOff = (int*)(fp + dex->pHeader->stringIdsOff);
        const u1* classIdx_stringdata = (u1*)fp+stringIdsOff[(*(typeIdsOff+dexClassDef->classIdx))];
        //解码
        readUnsignedLeb128(&classIdx_stringdata);
        printf("\n\t\tclassIdx\t\t--> ");
        while(*classIdx_stringdata != '\0')
        {
            printf("%c",(*classIdx_stringdata));
            classIdx_stringdata++;
        }


        printf("\n\t\taccessFlags\t\t-->\t%x",dexClassDef->accessFlags);

        //通过类型去寻找
        const u1* superclassIdx_stringdata = (u1*)fp+stringIdsOff[(*(typeIdsOff+dexClassDef->superclassIdx))];
        //解码
        readUnsignedLeb128(&superclassIdx_stringdata);
        printf("\n\t\tsuperclassIdx\t--> ");
        while(*superclassIdx_stringdata != '\0')
        {
            printf("%c",(*superclassIdx_stringdata));
            superclassIdx_stringdata++;
        }

        printf("\n\t\tinterfacesOff\t-->\t%d",dexClassDef->interfacesOff);

        if (dexClassDef->sourceFileIdx == -1)
        {
            printf("\n\t\tsourceFileIdx\t-->\tNO_INDEX");
        }
        printf("\n\t\tannotationsOff\t-->\t%d",dexClassDef->annotationsOff);
        printf("\n\t\tclassDataOff\t-->\t%d",dexClassDef->classDataOff);
        printf("\n\t\tstaticValuesOff\t-->\t%d",dexClassDef->staticValuesOff);


        dexClassDef++;
    }
}