同一个模块面向对象和面向过程的设计示例

设计1个位置指示器，功能是记录当前的位置和位置里的数据，并且可以新增位置，设置和获取位置数据等。可以用来记录当前按键移动的位置信息。

面向对象设计

这是我弄得面向对象的设计办法

test.hpp


#include <iostream>
#include <string.h>
#include <vector>
typedef struct PositionUnit{
    struct PositionUnit *LeftUnit;
    struct PositionUnit *RightUnit;
    struct PositionUnit *UpUnit;
    struct PositionUnit *DownUnit;
    void *Data;//必须是用new分配的空间
}PositionUnit,*PositionPointer;

template<typename T> class PositionSelecter{
public:
    virtual ~PositionSelecter(){
        for(auto &any:m_positionUnits){
            if(any->Data){
                delete static_cast<T*>(any->Data);//直接delete的办法释放
            }
            delete any;
        }
    }
    PositionSelecter(){
        PositionPointer pp = new_position_unit();
        m_currentPointer = pp;
        m_positionUnits.push_back(m_currentPointer);
    }
    void set_default_position_pointer_pos(){
        m_currentPointer = m_positionUnits.at(0);
    }
    bool set_current_pos_pointer_data(T *arg){
        if(m_currentPointer){
            static_cast<T*>(m_currentPointer->Data) = arg;
            return true;
        }
        return false;
    }
    T *get_current_pos_pointer_data(){
        if(m_currentPointer){
            return static_cast<T*>(m_currentPointer->Data);
        }
        return NULL;
    }
    bool add_left_unit(){
        if(m_currentPointer==NULL|| m_currentPointer->LeftUnit!=NULL){
            return false;
        }
        PositionPointer pp = new_position_unit();
        m_currentPointer->LeftUnit = pp;
        pp->RightUnit = m_currentPointer;
        m_positionUnits.push_back(pp);
        return true;
    }
    bool add_right_unit(){
        if(m_currentPointer==NULL|| m_currentPointer->RightUnit!=NULL){
            return false;
        }
        PositionPointer pp = new_position_unit();
        m_currentPointer->RightUnit = pp;
        pp->LeftUnit = m_currentPointer;
        m_positionUnits.push_back(pp);
        return true;
    }
    bool add_up_unit(){
        if(m_currentPointer==NULL|| m_currentPointer->UpUnit!=NULL){
            return false;
        }
        PositionPointer pp = new_position_unit();
        m_currentPointer->UpUnit = pp;
        pp->DownUnit = m_currentPointer;
        m_positionUnits.push_back(pp);
        return true;
    }
    bool add_down_unit(){
        if(m_currentPointer==NULL|| m_currentPointer->DownUnit!=NULL){
            return false;
        }
        PositionPointer pp = new_position_unit();
        m_currentPointer->DownUnit = pp;
        pp->UpUnit = m_currentPointer;
        m_positionUnits.push_back(pp);
        return true;
    }
    
    bool move_to_left_unit(){
        if(m_currentPointer == NULL||m_currentPointer->LeftUnit==NULL){
            return false;
        }
        m_currentPointer = m_currentPointer->LeftUnit;
        return true;
    }
    bool move_to_right_unit(){
        if(m_currentPointer == NULL||m_currentPointer->RightUnit==NULL){
            return false;
        }
        m_currentPointer = m_currentPointer->RightUnit;
        return true;
    }
    bool move_to_up_unit(){
        if(m_currentPointer == NULL||m_currentPointer->UpUnit==NULL){
            return false;
        }
        m_currentPointer = m_currentPointer->UpUnit;
        return true;
    }
    bool move_to_down_unit(){
        if(m_currentPointer == NULL||m_currentPointer->DownUnit==NULL){
            return false;
        }
        m_currentPointer = m_currentPointer->DownUnit;
        return true;
    }
private:
    PositionPointer new_position_unit(){
        PositionPointer pu = new PositionUnit;
        memset(pu,0,sizeof(PositionUnit));
        return pu;
    }
public:
    std::vector<PositionUnit*> m_positionUnits;
    PositionPointer m_currentPointer;
};

main.cpp

#include <iostream>
#include <string>
#include "test.hpp"

int main() {
    // 1. 创建选择器（int类型，也可以是其它类型比如自定义结构体、类）
    PositionSelecter<int> intSelector;
    
    // 2. 设置数据
    int* data1 = new int(100);
    if (intSelector.set_current_pos_pointer_data(data1)) {
        std::cout << "成功设置数据: " << *data1 << std::endl;
    }
    
    // 3. 获取数据
    int* retrieved = intSelector.get_current_pos_pointer_data();
    if (retrieved) {
        std::cout << "获取到的数据: " << *retrieved << std::endl;
    }
    
    // 4. 添加右侧单元
    if (intSelector.add_right_unit()) {
        std::cout << "成功添加右侧单元" << std::endl;
        
        // 移动到右侧
        if (intSelector.move_to_right_unit()) {
            std::cout << "成功移动到右侧单元" << std::endl;
            
            // 设置右侧单元的数据
            int* data2 = new int(200);
            intSelector.set_current_pos_pointer_data(data2);
        }
    }
    
    // 5. 返回到默认位置
    intSelector.set_default_position_pointer_pos();
    
    // 6. 自动清理：析构函数会自动调用，释放所有内存
    return 0;
}

面向过程设计

我嫌弃手动弄麻烦，就让AI转换成了一个c语言风格的面向过程设计版本，就是这个意思。让AI转换代码可以用，以前我把windows api所有A函数转换成W函数直接让AI转换，节省我大量时间并且没有错误。

position_unit.h

#ifndef POSITION_UNIT_H
#define POSITION_UNIT_H

#include <stdlib.h>
#include <string.h>

// 基本结构体定义
typedef struct PositionUnit {
    struct PositionUnit *LeftUnit;
    struct PositionUnit *RightUnit;
    struct PositionUnit *UpUnit;
    struct PositionUnit *DownUnit;
    void *Data;  // 必须用malloc分配的空间
} PositionUnit, *PositionPointer;

// 管理结构体
typedef struct PositionManager {
    PositionUnit** positionUnits;  // 动态数组
    int unitCount;
    int capacity;
    PositionPointer currentPointer;
} PositionManager;

// 创建和销毁
PositionManager* create_position_manager();
void destroy_position_manager(PositionManager* manager);

// 单元管理
PositionPointer create_position_unit();
void delete_position_unit(PositionPointer unit);

// 数据操作
int set_current_position_data(PositionManager* manager, void* data);
void* get_current_position_data(PositionManager* manager);

// 添加单元
int add_left_unit(PositionManager* manager);
int add_right_unit(PositionManager* manager);
int add_up_unit(PositionManager* manager);
int add_down_unit(PositionManager* manager);

// 移动操作
int move_to_left_unit(PositionManager* manager);
int move_to_right_unit(PositionManager* manager);
int move_to_up_unit(PositionManager* manager);
int move_to_down_unit(PositionManager* manager);

// 工具函数
void set_default_position_pointer(PositionManager* manager);
int add_unit_to_manager(PositionManager* manager, PositionPointer unit);

#endif // POSITION_UNIT_H

position_unit.c

#include "position_unit.h"
#include <stdio.h>

// 创建位置管理器
PositionManager* create_position_manager() {
    PositionManager* manager = (PositionManager*)malloc(sizeof(PositionManager));
    if (!manager) return NULL;
    
    manager->capacity = 10;
    manager->unitCount = 0;
    manager->currentPointer = NULL;
    
    manager->positionUnits = (PositionUnit**)malloc(sizeof(PositionUnit*) * manager->capacity);
    if (!manager->positionUnits) {
        free(manager);
        return NULL;
    }
    
    // 创建第一个单元
    PositionPointer pp = create_position_unit();
    if (!pp) {
        free(manager->positionUnits);
        free(manager);
        return NULL;
    }
    
    manager->currentPointer = pp;
    manager->positionUnits[0] = pp;
    manager->unitCount = 1;
    
    return manager;
}

// 销毁位置管理器
void destroy_position_manager(PositionManager* manager) {
    if (!manager) return;
    
    // 删除所有单元的数据和单元本身
    for (int i = 0; i < manager->unitCount; i++) {
        if (manager->positionUnits[i]) {
            PositionUnit* unit = manager->positionUnits[i];
            if (unit->Data) {
                free(unit->Data);  // 注意：这里是free，不是delete
            }
            free(unit);
        }
    }
    
    free(manager->positionUnits);
    free(manager);
}

// 创建位置单元
PositionPointer create_position_unit() {
    PositionPointer pu = (PositionPointer)malloc(sizeof(PositionUnit));
    if (!pu) return NULL;
    
    memset(pu, 0, sizeof(PositionUnit));
    return pu;
}

// 删除位置单元
void delete_position_unit(PositionPointer unit) {
    if (!unit) return;
    
    if (unit->Data) {
        free(unit->Data);
    }
    free(unit);
}

// 设置当前位置的数据
int set_current_position_data(PositionManager* manager, void* data) {
    if (!manager || !manager->currentPointer) {
        return 0;
    }
    
    // 如果已有数据，先释放
    if (manager->currentPointer->Data) {
        free(manager->currentPointer->Data);
    }
    
    manager->currentPointer->Data = data;
    return 1;
}

// 获取当前位置的数据
void* get_current_position_data(PositionManager* manager) {
    if (!manager || !manager->currentPointer) {
        return NULL;
    }
    return manager->currentPointer->Data;
}

// 设置默认位置指针
void set_default_position_pointer(PositionManager* manager) {
    if (!manager || manager->unitCount == 0) return;
    manager->currentPointer = manager->positionUnits[0];
}

// 添加单元到管理器
int add_unit_to_manager(PositionManager* manager, PositionPointer unit) {
    if (!manager || !unit) return 0;
    
    // 检查是否需要扩容
    if (manager->unitCount >= manager->capacity) {
        int newCapacity = manager->capacity * 2;
        PositionUnit** newArray = (PositionUnit**)realloc(
            manager->positionUnits, 
            sizeof(PositionUnit*) * newCapacity
        );
        
        if (!newArray) return 0;
        
        manager->positionUnits = newArray;
        manager->capacity = newCapacity;
    }
    
    manager->positionUnits[manager->unitCount] = unit;
    manager->unitCount++;
    return 1;
}

// 添加左边单元
int add_left_unit(PositionManager* manager) {
    if (!manager || !manager->currentPointer || manager->currentPointer->LeftUnit) {
        return 0;
    }
    
    PositionPointer pp = create_position_unit();
    if (!pp) return 0;
    
    manager->currentPointer->LeftUnit = pp;
    pp->RightUnit = manager->currentPointer;
    
    return add_unit_to_manager(manager, pp);
}

// 添加右边单元
int add_right_unit(PositionManager* manager) {
    if (!manager || !manager->currentPointer || manager->currentPointer->RightUnit) {
        return 0;
    }
    
    PositionPointer pp = create_position_unit();
    if (!pp) return 0;
    
    manager->currentPointer->RightUnit = pp;
    pp->LeftUnit = manager->currentPointer;
    
    return add_unit_to_manager(manager, pp);
}

// 添加上边单元
int add_up_unit(PositionManager* manager) {
    if (!manager || !manager->currentPointer || manager->currentPointer->UpUnit) {
        return 0;
    }
    
    PositionPointer pp = create_position_unit();
    if (!pp) return 0;
    
    manager->currentPointer->UpUnit = pp;
    pp->DownUnit = manager->currentPointer;
    
    return add_unit_to_manager(manager, pp);
}

// 添加下边单元
int add_down_unit(PositionManager* manager) {
    if (!manager || !manager->currentPointer || manager->currentPointer->DownUnit) {
        return 0;
    }
    
    PositionPointer pp = create_position_unit();
    if (!pp) return 0;
    
    manager->currentPointer->DownUnit = pp;
    pp->UpUnit = manager->currentPointer;
    
    return add_unit_to_manager(manager, pp);
}

// 移动到左边单元
int move_to_left_unit(PositionManager* manager) {
    if (!manager || !manager->currentPointer || !manager->currentPointer->LeftUnit) {
        return 0;
    }
    
    manager->currentPointer = manager->currentPointer->LeftUnit;
    return 1;
}

// 移动到右边单元
int move_to_right_unit(PositionManager* manager) {
    if (!manager || !manager->currentPointer || !manager->currentPointer->RightUnit) {
        return 0;
    }
    
    manager->currentPointer = manager->currentPointer->RightUnit;
    return 1;
}

// 移动到上边单元
int move_to_up_unit(PositionManager* manager) {
    if (!manager || !manager->currentPointer || !manager->currentPointer->UpUnit) {
        return 0;
    }
    
    manager->currentPointer = manager->currentPointer->UpUnit;
    return 1;
}

// 移动到下边单元
int move_to_down_unit(PositionManager* manager) {
    if (!manager || !manager->currentPointer || !manager->currentPointer->DownUnit) {
        return 0;
    }
    
    manager->currentPointer = manager->currentPointer->DownUnit;
    return 1;
}

main.c

#include "position_unit.h"
#include <stdio.h>

// 自定义数据类型示例
typedef struct {
    int id;
    char name[50];
    float value;
} MyData;

int main() {
    // 创建管理器
    PositionManager* manager = create_position_manager();
    if (!manager) {
        printf("创建管理器失败\n");
        return 1;
    }
    
    // 创建并设置数据
    MyData* data1 = (MyData*)malloc(sizeof(MyData));
    if (data1) {
        data1->id = 1;
        strcpy(data1->name, "第一个节点");
        data1->value = 3.14f;
        set_current_position_data(manager, data1);
    }
    
    // 添加右边单元
    if (add_right_unit(manager)) {
        printf("成功添加右边单元\n");
        
        // 移动到右边
        move_to_right_unit(manager);
        
        // 设置右边单元的数据
        MyData* data2 = (MyData*)malloc(sizeof(MyData));
        if (data2) {
            data2->id = 2;
            strcpy(data2->name, "第二个节点");
            data2->value = 2.718f;
            set_current_position_data(manager, data2);
        }
        
        // 获取并显示数据
        MyData* retrieved = (MyData*)get_current_position_data(manager);
        if (retrieved) {
            printf("当前节点: ID=%d, Name=%s, Value=%.2f\n", 
                   retrieved->id, retrieved->name, retrieved->value);
        }
        
        // 移回左边
        move_to_left_unit(manager);
    }
    
    // 添加下边单元
    if (add_down_unit(manager)) {
        printf("成功添加下边单元\n");
        
        // 移动到下边
        move_to_down_unit(manager);
        
        // 可以继续添加其他方向...
    }
    
    // 返回默认位置
    set_default_position_pointer(manager);
    
    // 清理
    destroy_position_manager(manager);
    
    return 0;
}

总结

创建和释放数据的时候，cpp风格是使用new和delete，使用它们进行创建和释放需要知道数据类型，所以使用了模板类。

c风格是使用malloc和free，它们不需要知道数据类型，直接在类里析构函数释放就行了。