在面向接口、面向對象編程的過程中，會遇到實際物體類別與定義類別相分離的情況。

例如，我們有三種物體，他們的固有類別分別為： TYPEA，TYPEB，TYPEC。在我們實際使用過程中，我們會根據不同的情況將他們分成 2 組： Group1，Group2。

那麽，我們在定義結構體和物理類別時，需要註意對 Group 進行定義。定義物體具體屬性和結構體如下：

#define TYPEA (0x01UL << 0)
#define TYPEB (0x01UL << 1)
#define TYPEC (0x01UL << 2)

typedef struct foo_t {
   ...
   uint64_t group1;
   uint64_t group2;
   ...
} foo_t

在定義具體類型時，我們可以進行具體物體分類的實現：

foo_t fooA = {
    .group1 = TYPEA | TYPEB;
    .group2 = TYPEC;
};

foo_t fooB = {
    .group1 = TYPEA;
    .group2 = TYPEB | TYPEC;
};

uint64_t thingA = TYPEA;
uint64_t thignB = TYPEB;

通過定義，我們實現了兩種具體的分類方式，fooA 和 fooB，並且實現了具體分組和物品類型的關聯。並且，我們定義了兩個具體的事物，thingA 和 thingB。

在實際編程過程中，我們對 thing 的判斷方式如下：

uint64_t thingX = ...;

if (thingX & fooA.group1) {
    printf("ThingX insert into A.group1\n");
} else if (thingX & fooA.group2) {
    printf("ThingX insert into A.group2\n");
}

在具體代碼使用過程中，我們不必再關心物品的固有類型，以及分組的類型。當需要修改分組類型時，我們只需要修改 group 定義時的類型，就能夠實現類型的變更。

通過分組的抽象，與對抽象結果的使用，可以減少後期代碼維護時的工作量。

當我們需要檢測分析信息時，我們可以通過使用實際的類型，進行檢測：

if (fooA.group1 & TYPEA) {
    printf("A.group1 contains TYPEA");
}
if (fooA.group1 & TYPEB) {
    printf("A.group1 contains TYPEB");
}
if (fooA.group1 & TYPEC) {
    printf("A.group1 contains TYPEC");
}


if (thingX & TYPEA) {
    printf("thingX belong to TYPEA");
} else if (thingX & TYPEB) {
    printf("thingX belong to TYPEB");
} else if (thingX & TYPEC) {
    printf("thingX belong to TYPEC");
}

在開發後期，可能會出現新的分類方式，對原有類型進行了分離。例如：TYPEA 分離成 TYPED 和 TYPEF，修改信息如下：

#define TYPED (0x01UL << 4)
#define TYPEF (0x01UL << 5)
#define TYPEA (TYPED | TYPEF)

通過對 TYPEA 的分離，原有 TYPEA 的邏輯並不需要進行更新，TYPED 和 TYPEF 相關的新邏輯添加就可以了。

這種情況下，原有類型 fooA 相關代碼不需要進行更新，而新類型 fooX 可以添加 TYPED 和 TYPEF 的操作。

關於物體 '固有類別' 與 '實際使用類別' 分離的情況，結構體定義方法