IProcessor* CreateAoiProcessor() {
    return new CAoiProcessor();
}

void ReleaseProcessor(IProcessor* pProcessor) {
    delete pProcessor;
}

// unique_ptr 對(duì)象池版本源碼
#pragma once

#include <stack>
#include <memory>
#include <mutex>

/**
 * @brief 通用的處理器對(duì)象池模板。
 * @tparam T 實(shí)際實(shí)現(xiàn) IProcessor 的派生類。
 */
template <typename T>
class ProcessorObjectPool {
public:
    using Ptr = std::unique_ptr<T>;

    /**
     * @brief 獲取一個(gè)處理器對(duì)象。
     * @return 智能指針，包裝了一個(gè) T 類型實(shí)例。
     */
    Ptr Acquire();

    /**
     * @brief 回收一個(gè)處理器對(duì)象。
     * @param pObj 要回收的對(duì)象（智能指針）。
     */
    void Release(Ptr pObj);

    /**
     * @brief 獲取對(duì)象池的單例實(shí)例。
     * @return 靜態(tài)的對(duì)象池實(shí)例。
     */
    static ProcessorObjectPool<T>& Instance();

private:
    ProcessorObjectPool() = default;
    ~ProcessorObjectPool() = default;

    ProcessorObjectPool(const ProcessorObjectPool&) = delete;
    ProcessorObjectPool& operator=(const ProcessorObjectPool&) = delete;

    std::stack<Ptr> m_pool;
    std::mutex m_mutex;
    static constexpr std::size_t MAX_POOL_SIZE = 64;  ///< 池中最大緩存對(duì)象數(shù)量
};

// 模板實(shí)現(xiàn)必須包含在頭文件中
#include "ProcessorObjectPool.inl"

//============================================================================================
//============================================================================================

// shared_ptr 對(duì)象池版本源碼
#pragma once

#include <array>
#include <memory>
#include <mutex>
#include <bitset>
#include <cstddef>

/**
 * @file ProcessorObjectPool.h
 * @brief 基于靜態(tài)內(nèi)存的對(duì)象池模板類，適配 MISRA / AUTOSAR C++。
 * @tparam T 對(duì)象類型（必須支持默認(rèn)構(gòu)造）。
 * @tparam N 對(duì)象池大小，最大可同時(shí)持有的對(duì)象數(shù)量。
 */
template <typename T, std::size_t N>
class ProcessorObjectPool {
public:
    /**
     * @brief 對(duì)象指針類型，使用 shared_ptr 包裝，帶自定義回收邏輯。
     */
    using Ptr = std::shared_ptr<T>;

    /**
     * @brief 獲取對(duì)象池的單例實(shí)例。
     * @return 返回靜態(tài)單例。
     */
    static ProcessorObjectPool& Instance();

    /**
     * @brief 獲取一個(gè)可用對(duì)象指針。
     * @return 有效 shared_ptr，如果池已滿返回空指針。
     */
    Ptr Acquire();

    /**
     * @brief 回收對(duì)象指針（由 shared_ptr 的 deleter 調(diào)用）。
     * @param pObj 需回收的對(duì)象指針。
     */
    void Recycle(T* pObj);

private:
    ProcessorObjectPool() = default;
    ~ProcessorObjectPool() = default;

    // 禁止復(fù)制與賦值
    ProcessorObjectPool(const ProcessorObjectPool&) = delete;
    ProcessorObjectPool& operator=(const ProcessorObjectPool&) = delete;

    std::array<T, N> m_objects;     ///< 靜態(tài)分配的對(duì)象數(shù)組
    std::bitset<N> m_used{};        ///< 標(biāo)記哪些對(duì)象已被占用
    std::mutex m_mutex;             ///< 互斥鎖，保護(hù)并發(fā)訪問
};

#include "ProcessorObjectPool.inl"  // 模板實(shí)現(xiàn)必須放頭文件中

// 這里預(yù)留 unique_ptr 對(duì)象池版本實(shí)現(xiàn)
#pragma once

#include <utility>

template <typename T>
typename ProcessorObjectPool<T>::Ptr ProcessorObjectPool<T>::Acquire() {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (!m_pool.empty()) {
        Ptr obj = std::move(m_pool.top());
        m_pool.pop();
        return obj;
    } else {
        return std::unique_ptr<T>(new T());  // C++14 不能用 make_unique
    }
}

template <typename T>
void ProcessorObjectPool<T>::Release(Ptr pObj) {
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_pool.size() < MAX_POOL_SIZE) {
        m_pool.push(std::move(pObj));
    } else {
        // 超出限制，自動(dòng)釋放，不入池
    }
}

template <typename T>
ProcessorObjectPool<T>& ProcessorObjectPool<T>::Instance() {
    static ProcessorObjectPool<T> instance;
    return instance;
}

//============================================================================================
//============================================================================================

// 這里預(yù)留 shared_ptr 對(duì)象池版本實(shí)現(xiàn)
#pragma once

/**
 * @brief 獲取單例對(duì)象池實(shí)例。
 */
template <typename T, std::size_t N>
ProcessorObjectPool<T, N>& ProcessorObjectPool<T, N>::Instance()
{
    static ProcessorObjectPool<T, N> instance;
    return instance;
}

/**
 * @brief 獲取一個(gè)可用對(duì)象的 shared_ptr。
 *        若池中存在未使用對(duì)象，則直接返回；
 *        若全部占用，則返回空 shared_ptr。
 */
template <typename T, std::size_t N>
typename ProcessorObjectPool<T, N>::Ptr ProcessorObjectPool<T, N>::Acquire()
{
    std::lock_guard<std::mutex> lock(m_mutex);

    T* pRaw = nullptr;
    for (std::size_t i = 0; i < N; ++i) {
        if (!m_used[i]) {
            m_used[i] = true;
            pRaw = &m_objects[i];
            break;
        }
    }

    Ptr result;
    if (pRaw != nullptr) {
        // 創(chuàng)建 shared_ptr，附帶回收 deleter
        result = Ptr(pRaw, [](T* p) {
            ProcessorObjectPool<T, N>::Instance().Recycle(p);
        });
    }

    return result;
}

/**
 * @brief 回收一個(gè)對(duì)象指針回池中。
 * @param pObj 需釋放的對(duì)象，必須為池中對(duì)象。
 */
template <typename T, std::size_t N>
void ProcessorObjectPool<T, N>::Recycle(T* pObj)
{
    if (nullptr == pObj) {
	    return;
    }

    std::lock_guard<std::mutex> lock(m_mutex);
    const std::ptrdiff_t nIndex = pObj - m_objects.data();
    if ((nIndex >= 0) && (static_cast<std::size_t>(nIndex) < N)) {
        m_used[static_cast<std::size_t>(nIndex)] = false;
        // 注意：對(duì)象不會(huì)析構(gòu)。若對(duì)象含狀態(tài)，應(yīng)在 T 內(nèi)部自行 reset()
        pObj->Reset();
    }
}

// ProcessorFactory 舊源碼
#include "pch.h"
#include "ProcessorFactory.h"

#include "AoiProcessor.h"
#include "ControllerProcessor.h"

extern "C" {
    IProcessor* CreateAoiProcessor() {
        return new CAoiProcessor();
    }

    IProcessor* CreateControllerProcessor() {
        return new CControllerProcessor();
    }

    void ReleaseProcessor(IProcessor* pProcessor) {
        if (pProcessor) {
            delete pProcessor;
        }
    }
}

//============================================================================================
//============================================================================================

// ProcessorFactory 新源碼
#include "pch.h"
#include "ProcessorFactory.h"
#include "AoiProcessor.h"
#include "ControllerProcessor.h"
#include "ProcessorObjectPool.h"

// 使用靜態(tài)池管理對(duì)象（不使用 new/delete）
using AoiProcessorPool = ProcessorObjectPool<CAoiProcessor, 32>;
using CtrlProcessorPool = ProcessorObjectPool<CControllerProcessor, 32>;

// 內(nèi)部共享引用池，避免 shared_ptr 提前析構(gòu)
static std::vector<std::shared_ptr<IProcessor>> s_processorRefs;
static std::mutex s_mutex;

extern "C" {
    IProcessor* CreateProcessor(int nType) {
        std::shared_ptr<IProcessor> sp;
        IProcessor* pRaw = nullptr;

        if (nType == 0) {
            sp = AoiProcessorPool::Instance().Acquire();
        }
        else if (nType == 1) {
            sp = CtrlProcessorPool::Instance().Acquire();
        }
        else {
            sp = nullptr;
		}

        if (sp) {
            pRaw = sp.get();
            std::lock_guard<std::mutex> lock(s_mutex);
            s_processorRefs.emplace_back(std::move(sp));
        }

        return pRaw;
    }

    void ReleaseProcessor(IProcessor* pProcessor) {
        if (pProcessor == nullptr) {
            return;
        }

        std::lock_guard<std::mutex> lock(s_mutex);
        auto it = std::remove_if(s_processorRefs.begin(), s_processorRefs.end(), [=](const std::shared_ptr<IProcessor>& ptr) {
        	return ptr.get() == pProcessor;
        });
        s_processorRefs.erase(it, s_processorRefs.end());
    }
}