20_结构体共用体枚举

结构体

  1. 结构体嵌套结构体后的大小,只算嵌套结构体中的最大值

  1. 网络数据包中没有规定对齐值,所有都是连续排放,使用C/c++设置对齐值为1
  2. 栈空间取模4对齐
  3. C++嵌套的结构时候,在嵌套里面写定义就为私有的,访问的时候使用::访问某类型下
  4. C++嵌套如果不写名字的话就等于黑心厂
  5. 同一空间反复利用,结构体定义一个最大的数据类型,然后使用的时候强转地址

预处理

1.#pragma pack(1) //设置后面结构体的数据成员对齐值为1

#pragma pack(8) //到这里恢复

2. 不破坏别人的对齐值,避免区分谁先包含的问题

#pragma pack(push) //保存原对齐值,可以用逗号分隔先保存,再设置对齐值

#pragma pack(16) //设置16对齐

Struct tagXX //这个结构体使用这个对齐大小

{

};

#pragma pack(pop) //恢复原对齐值

#undef 取消宏定义

杂项

Void *表示的是地址

Void *可以接受任何地址,任何地址

Void *不能直接赋值给指针,需要强转表解析方式

Float获得编码,直接强转变量地址成为整形地址方式

语法糖(共用体)

  1. 语法糖属于锦上添花

Union unScored

{

Char cLeve;

Int nSource;

Double dblScore;

Char *szTest;

}

2.原理就是取最大的数据类型强转地址,赋值当前的数据类型的值到最大的数据类型地址

Enum枚举

    1. 编译器自动赋唯一值
    2. 只能枚举变量给枚举定义列表之内的值,常量也不行
    3. 不能给以外的值
    4. 最后一次,往后累加,不能重复定义
    5. 宏整个工程都受影响,枚举可以变成作用域宏(控制使用范围)
    6. 也可以不让外面用
    7. 只能取代整数型宏

变体

1.VARINT

2.各个类型VT_INT

3.封装了函数 _variant_t

作业

1.Memcpy

 
#include 
#include 

void *myMemcpy(void *dest, const void *src, size_t count)
{
    size_t i = 0;
    char *pDest = (char *)dest;
    char *pSrc = (char *)src;

    for (i = 0; i < count; i++)
    {
        *pDest = *pSrc;
        pDest++;
        pSrc++;
    }

    return (void *)pDest;
}

int main()
{

    char *s = "http://www.runoob.com";
    char d[20];
    myMemcpy(d, s + 11, 6);// 从第 11 个字符(r)开始复制,连续复制 6 个字符(runoob)
                         // 或者 memcpy(d, s+11*sizeof(char), 6*sizeof(char));
    d[6] = '\0';
    printf("%s", d);

    return 0;
}

2.自己实现VARINT,GetInt(),SetInt(),六个类型

 
#include 

struct tagVariant
{
    union uVtSize
    {
        double dblSize;
    };

    enum eType
    {
        VT_CHAR,
        VT_SHOTIINT,
        VT_INT,
        VT_FLOAT,
        VT_DOUBLE
    }TYPE;
};

void setChar(struct tagVariant *pVariant, char cValue)
{
    pVariant->dblSize = cValue;
    pVariant->TYPE = VT_CHAR;
}

void setSHORIINT(struct tagVariant *pVariant, short int wValue)
{
    pVariant->dblSize = wValue;
    pVariant->TYPE = VT_SHOTIINT;
}

void setInt(struct tagVariant *pVariant, int nValue)
{
    pVariant->dblSize = nValue;
    pVariant->TYPE = VT_INT;
}

void setFloat(struct tagVariant *pVariant, float fValue)
{
    pVariant->dblSize = fValue;
    pVariant->TYPE = VT_FLOAT;
}

void setDouble(struct tagVariant *pVariant, double dblValue)
{
    pVariant->dblSize = dblValue;
    pVariant->TYPE = VT_DOUBLE;
}

char getChar(struct tagVariant *pVariant)
{
    return (char)pVariant->dblSize;
}

short int getSHORIINT(struct tagVariant *pVariant)
{
    return (short int)pVariant->dblSize;
}

int getInt(struct tagVariant *pVariant)
{
    return (int)pVariant->dblSize;
}

float getFloat(struct tagVariant *pVariant)
{
    return (float)pVariant->dblSize;
}

double getDouble(struct tagVariant *pVariant)
{
    return (double)pVariant->dblSize;
}

int main()
{
    struct tagVariant variant;

    return 0;
}
0 条评论
发表一条评论