第八章 组件复用：包容与聚合【代码】

已于 2024-09-03 18:47:55 修改
阅读量289 收藏 3
点赞数 1
分类专栏： COM技术内幕读书笔记 文章标签： composer
于 2024-08-17 11:49:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_74544400/article/details/141278226
版权

8.4 一个完整的例子

下面我们将实现一个聚合了一个接口的组件。在这个例子中,组件1支持两个接口IX和IY。但它只实现了接口IX,而没有实现接口IY,并且也并没有将此接口调用转发给组件2的实现。相反,当客户向组件1查询接口IY时,组件1将返回内部组件即组件2所实现的IY接口的指针。程序清单8-3给出的是外部组件的实现,程序清单8-4则是内部组件的实现。客户基本上没有什么变化,因它并不关心我们使用的是包容还是聚合。

// 程序清单8-3 外部组件(聚合组件)的实现。
//
// Cmpnt1.cpp - Component1
//
//
#include <iostream>
#include "Iface.h"
#include "Registry.h"

using namespace std;

void trace(const char* msg) 
{ 
	cout << "Component 1:\t" << msg << endl; 
}
///
//
// Global variables 全局变量
//
// Static variables 静态变量
static HMODULE g_hModule = NULL;            // DLL module handle DLL 模块句柄 用于跟踪模块句柄
static long g_cComponents = 0;              // Count of active components 活动组件计数 组件实例数量
static long g_cServerLocks = 0;             // Count of locks 锁计数 服务器锁定状态

// Friendly name of component 组件的友好名称
const char g_szFriendlyName[]
= "Inside COM, Chapter 8 Example 2, Component 1";

// Version-independent ProgID 无关的ProgID
const char g_szVerIndProgID[] = "InsideCOM.Chap08.Ex2.Cmpnt1";

// ProgID
const char g_szProgID[] = "InsideCOM.Chap08.Ex2.Cmpnt1.1";

///
//
// Component A 组件A
// 定义了 CA 类，继承接口 IX。
// 实现聚合其他组件的功能，通过 QueryInterface 支持接口查询，AddRef 和 Release 处理引用计数。
class CA : public IX
    // public IY
{
public:
    // IUnknown
    virtual HRESULT __stdcall QueryInterface(const IID& iid, void** ppv);
    virtual ULONG   __stdcall AddRef();
    virtual ULONG   __stdcall Release();

    // Interface IX 接口IY
    virtual void __stdcall Fx() { cout << "Fx" << endl; }

    /* Component aggregates instead of implementation interface IY. 组件聚合而不是实现接口IY
    // Interface IY 接口IY
    virtual void __stdcall Fy() { m_pIY->Fy(); }
    */

    // Constructor
    CA();
    // Destructor
    ~CA();

    // Initialization function called by the class factory to create contained component
    // 由类工厂调用的初始化函数，用于创建包含的组件
    HRESULT __stdcall Init();

private:
    // Reference count
    long m_cRef; // 引用计数

    // Pointer to the aggregated component's IY Interface 指向聚合组件的IY接口的指针
    // (We do not have to retain an IY pointer. However, we can use it in QueryInterface.)
    // (我们不需要保留y指针。但是，我们可以在QueryInterface中使用它。)
    IY* m_pIY; // 指向被聚合组件的 IY 接口

    // Pointer to inner component's IUnknown
    // 指向内部组件IUnknown的指针
    IUnknown* m_pUnknownInner; // 指向内部组件的 IUnknown 接口
}

//
// Constructor
//初始化组件 CA，设置初始引用计数为 1，并将指向内部组件的指针设为 NULL，同时增加全局组件计数
CA::CA()
    : m_cRef(1),
    m_pUnknownInner(NULL)
{
    InterlockedIncrement(&g_cComponents); // 增加全局组件计数
}

//
// Destructor
// 析构函数在销毁 CA 时，减少全局组件计数，防止递归销毁，并释放指向内部组件的指针。
CA::~CA()
{
    InterlockedDecrement(&g_cComponents); // 减少全局组件计数
    trace("Destroy self."); // 输出销毁信息

    // Prevent recursive destruction on next AddRef/Release pair.
    // 防止下一个AddRef/Release对的递归销毁。
    m_cRef = 1; // 防止递归销毁

    // Counter the pUnknownOuter->Release in the Init method.
    IUnknown* pUnknownOuter = this;
    pUnknownOuter->AddRef(); // 增加外部引用计数以防止递归问题

    // Properly release the pointer: there may be per-interface reference counts.
    // 正确释放指针:可能存在每个接口的引用计数。
    m_pIY->Release(); // 释放内部接口指针

    // Release contained component
    if (m_pUnknownInnter != NULL) {
        m_pUnknownInnter->Release();// 释放内部组件
    }
}

// Initailize the component by creating the contained component.
// 通过创建包含的组件来初始化组件。
// Init 函数用于初始化组件 CA，创建内部组件，并获取其 IY 接口。如果组件创建失败或接口不支持，则释放资源并返回错误。
HRESULT __stdcall CA::Init()
{
    // Get the pointer to the outer unknown.
    // 获取指向外部未知的指针。
    // Since this component is not aggregated. the outer unknown is the same as the this pointer.
    // 因为这个组件没有聚合。外部unknown与this指针相同。
    IUnknown* pUnknownOuter = this;
    trace("Create inner component.");
    HRESULT hr =
        ::CoCreateInstance(CLSID_Component2,
            pUnknownOuter,   // Outer component's IUnknown 外部组件未知
            CLSCTX_INPROC_SERVER,
            IID_IUnknown,    // IUnknown when aggregating 聚合时未知
            (void**)&m_pUnknownInner);
    if (FAILED(hr)) {
        trace("Could not create contained component.");
        return E_FAIL;
    }

    // This call will increment the reference count on the outer component.
    // 这个调用将增加外部组件上的引用计数。
    trace("Get the IY interface from the inner component.");
    hr = m_pUnknownInner->QueryInterface(IID_IY, (void**)&m_pIY);
    if (FAILED(hr)) {
        trace("Inner component does not support interface IY.");
        m_pUnknownInner->Release();
        return E_FAIL;
    }

    // We need to release the reference count added to the outer component in the above call.
    // 我们需要释放在上述调用中添加到外部组件的引用计数。
    // So call Release on the pointer you passed to CoCreateInstance.
    // 所以在你传递给CoCreateInstance的指针上调用Release。
    pUnknownOuter->Release(); // 释放外部组件引用计数
    return S_OK;
}

//
// IUnknown implementation IUnknown实现
// QueryInterface 用于查询对象支持的接口，并返回相应的接口指针；
HRESULT __stdcall CA::QueryInterface(const IID& iid, void** ppv)
{
    if (iid == IID_IUnknown) {
        *ppv = static_cast<IUnknown*>(this);
    }
    else if (iid == IID_IX) {
        *ppv = static_cast<IX*>(this);
    }
    else if (iid == IID_IY) {
        trace("Return inner component's IY interface.");
// #if 1 ... #else ... #endif 是一个预处理指令，用于控制代码的条件编译。
// 在这里，它用于选择两种不同的处理 IID_IY 接口请求的方式。这部分代码允许你灵活地选择查询接口信息或者返回缓存的接口指针
#if 1
        // You can query for the interface.
        //可以查询接口信息。
        return m_pUnknownInner->QueryInterface(iid, ppv);
#else 
        // Or you can return a cached pointer.
        // 或者你可以返回一个缓存的指针。
        * ppv = m_pIY;
        // Fall through so it will get AddRef'ed
#endif
    }
    else {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
    reinterpret_cast<IUnknown*>(*ppv)->AddRef();
    return S_OK;
}

// AddRef 增加引用计数；Release 减少引用计数并在必要时销毁对象。
ULONG __stdcall CA::AddRef()
{
    retrun InterlockedIncrement(&m_cRef);
}

ULONG __stdcall CA::Release()
{
    if (InterlockedDecrement(&m_cRef) == 0) 
    {
        delete this;
        return 0;
    }
    return m_cRef;
}

///
// 
// Class Factory 类厂
// 实现 IClassFactory 接口，负责创建组件实例 (CreateInstance) 并管理服务器锁 (LockServer)。
class CFactory : public IClassFactory
{
public:
    // IUnknown
    virtual HRESULT __stdcall QueryInterface(cosnt IID& iid, void** ppv);
    virtual ULONG   __stdcall AddRef();
    virtual ULONG   __stdcall Release();

    // Interface IClassFactory 接口IClassFactory
    virtual HRESULT __stdcall CreateInstance(IUnknown* pUnknownOuter,
        const IID& iid,
        void** ppv);
    virtual HRESULT __stdcall LockServer(BOOL bLock);

    // Constructor
    CFactory() : m_cRef(1) {}// 初始化引用计数为 1

    // Destructor
    ~CFactory() {}

private:
    long m_cRef;
}

// 
// Class factory IUnknown implemenation
//类工厂:IUnknown的实现
// 用于返回 IClassFactory 或 IUnknown 接口
HRESULT __stdcall CFactory::QueryInstance(REFIID iid, void** ppv)
{
    IUnknown* pI;
    if ((iid == IID_IUnknown) || (iid == IID_IClassFactory)) 
    {
        pI = static_cast<IClassFactory*>(this);
    }
    else {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
    pI->AddRef(); // 增加引用计数
    *ppv = pI; // 返回指向请求的接口
    return S_OK;
}

// AddRef 和 Release 用于管理类工厂的引用计数
ULONG CFactory::AddRef()
{
    return InterlockedIncrement(&m_cRef); // 增加类工厂的引用计数
}

ULONG CFactory::Release()
{
    if (InterlockedDecrement(&m_cRef)) // 减少引用计数，如果为 0 则删除对象
    {
        delete this;
        return 0;
    }
    return m_cRef;
}

// 
// IClassFactory implementation
// IClassFactory实现  用于创建 CA 组件的实例并返回请求的接口
HRESULT __stdcall CFactory::CreateInstance(IUnknown* pUnknownOuter,
    const IID& iid,
    void** ppv)
{
    HRESULT hr = E_FAIL;
    // Cannot aggregate 不支持聚合
    if (pUnknownOuter != NULL) {
        return CLASS_E_NOAGGREGATION;
    }

    // Create component. 创建组件实例
    CA* pA = new CA;
    if (pA == NULL) {
        return E_OUTOFMEMORY;
    }

    // Initialize the component. 初始化组件
    hr = pA->Init();
    if (FAILED(hr)) {
        // Initialization failed. Delete component.
        // 初始化失败，删除组件。
        pA->Release();
        return hr;
    }

    // Get the requested interface. 获取所请求的接口。
    hr = pA->QuerInterface(iid, ppv);
    pA->Release();// 释放组件（即使 QueryInterface 成功）
    return hr;
}

// LockServer控制服务器的锁定状态，影响组件是否可以卸载。
HRESULT __stdcall CFactory::LockServer(BOOL bLock)
{
    if (bLock) {
        InterlockedIncrement(&g_cServerLocks); // 增加锁计数
    }
    else {
        InterlockedDecrement(&g_cServerLocks); // 减少锁计数
    }
    return S_OK;
}

///
// 
// Exported functions
// 输出功能：用于决定 DLL 是否可以从内存中卸载，当没有活动组件且服务器未被锁定时返回 S_OK，允许卸载
STDAPI DllCanUnloadNow()
{
	// 当组件计数和服务器锁都为 0 时，允许卸载 DLL
    if (g_cComponents == 0) && (g_cServerLocks == 0)) {
    return S_OK;
    }
    else {
        return S_FALSE;
    }
}

// 
// Get class factory.
//获取类工厂。DllGetClassObject 用于创建类工厂的实例，并返回请求的接口，用于对象的创建过程
STDAPI DllGetClassObject(const CLSID& clsid,
    const IID& iid,
    void** ppv)
{
    // Can we create this component?
    // 检查是否可以创建指定的组件
    if (clsid != CLSID_Component1) {
        return CLASS_E_CLASSNOTAVAILABLE;
    }

    // Create class factory.
    // 创建类工厂
    CFactory* pFactory = new CFactory;  // No AddRef in constructor
    if (pFactory == NULL) 
    {
        return E_OUTOFMEMORY;
    }

    // Get requested interface.
    // 获取请求的接口
    HRESULT hr = pFactory->QueryInterface(iid, ppv);
    pFactory->Release();// 释放类工厂

    return hr;
}

// 
// Server registration 服务器注册
// DllRegisterServer 和 DllUnregisterServer 用于将组件注册到系统中或者从系统中移除。
STDAPI DllRegisterServer()
{
	// 调用 RegisterServer 注册组件
    return RegisterServer(g_hModule,
        CLSID_Component1,
        g_szFriendlyName,
        g_szVerIndProgID,
        g_szProgID);
}

STDAPI DllUnregisterServer()
{
	// 调用 UnregisterServer 反注册组件
    return UnregisterServer(CLSID_Component1,
        g_szVerIndProgID,
        g_szProgID);
}

///
// 
// DLL module information
// DLL 主入口点
// DllMain 是 DLL 的主入口点，用于处理 DLL 加载和卸载的事件
// 在 DLL_PROCESS_ATTACH 时保存模块句柄，以供其他函数使用。
BOOL APIENTRY DllMain(HANDLE hModule,
    DWORD dwReason,
    void* lpReserved)
{
    if (dwReason == DLL_PROCESS_ATTACH) {
        g_hModule = hModule; // 保存模块句柄
    }
    return TRUE; // 返回 TRUE 表示初始化成功
}

// 程序清单8-4 内部组件(被聚合组件)的实现。
//
// Cmpnt2.cpp - Component 2
// Note the changes in the class factory marked with
//请注意类工厂中标记的更改
#include <iostream>
#include <objbase.h>
#include "Iface.h"// 包含接口的定义
#include "Registry.h" // 包含注册表操作的定义

using namespace std;

void trace(const char* msg) 
{ 
	cout << "Component2:\t" << msg << endl; 
}

///
//
// Global variables
// 全局变量

// Static variables
static HMODULE g_hModule = NULL;        // DLL module handle // DLL 模块句柄
static long g_cComponents = 0;          // Count of active components 活跃组件的计数
static long g_cServerLocks = 0;         // Count of locks 锁计数

// Friendly name of component 组件友好名称
const char g_szFriendlyName[]
= "Inside COM, Chapter 8 Example 2, Component 2";

// Version-independent ProgID 版本无关的 ProgID
const char g_szVerIndProgID[] = "InsideCOM.Chap08.Ex2.Cmpnt2";

// ProgID
const char g_szProgID[] = "InsideCOM.Chap08.Ex2.Cmpnt2.1";

///
//
// Nondelegating IUnknown interface
// INondelegatingUnknown 接口
// 定义了一个非委托的 IUnknown 接口，用于组件的内部接口管理
struct INondelegatingUnknown
{
    virtual HRESULT __stdcall NondelegatingQueryInterface(const IID&, void**) = 0;
    virtual ULONG __stdcall NondelegatingAddRef() = 0;
    virtual ULONG __stdcall NondelegatingRelease() = 0;
};

///
//
// Component
// 组件类 CB
class CB : public IY,INondelegatingUnknown
// CB 类实现了 IY 和 INondelegatingUnknown 接口。
{
    {
public:
	// CB 类实现了 IY 和 INondelegatingUnknown 接口。
    // Delegating IUnknown
    virtual HRESULT __stdcall QueryInterface(const IID& iid, void** ppv)
    {
        trace("Delegate QueryInterface.");
        return m_pUnknownOuter->QueryInterface(iid, ppv);
    }

    virtual ULONG __stdcall AddRef()
    {
        trace("Delegate AddRef.");
        return m_pUnknownOuter->AddRef();
    }

    virtual ULONG __stdcall Release()
    {
        trace("Delegate Release.");
        return m_pUnknownOuter->Release();
    }

    // Nondelegating IUnknown
    // NondelegatingQueryInterface、NondelegatingAddRef 和 NondelegatingRelease 是非委托的 IUnknown 实现，用于组件内部接口的管理。
    virtual HRESULT __stdcall
        NondelegatingQueryInterface(const IID& iid, void** ppv);
    virtual ULONG __stdcall NondelegatingAddRef();
    virtual ULONG __stdcall NondelegatingRelease();

    // Interface IY
    // Fy() 是 IY 接口的方法实现，输出 Fy
    virtual void __stdcall Fy() { cout << "Fy" << endl; }

    // Constructor
    CB(IUnknown* m_pUnknownOuter);

    // Destructor
    ~CB();

private:
    long m_cRef;
    IUnknown* m_pUnknownOuter;
}

//
// IUnknown implementation
// IUnknown实现
// NondelegatingQueryInterface 实现了内部接口的查询，使用非委托的接口进行强制类型转换
HRESULT __stdcall CB::NondelegatingQueryInterface(const IID& iid, void** ppv)
{
    if (iid == IID_IUnknown) {
        // !!! CAST IS VERY IMPORTANT!!!
        // 类型转换 它确保返回的是非委托的 IUnknown 实现，而不是被聚合时返回给外部组件的 IUnknown
        // 强制转换确保返回的是内部组件自己的 INondelegatingUnknown 实现，而不是其他接口。
        // 这是保证组件能够正确管理自身行为的关键步骤
        *ppv = static_cast<INondelegatingUnknown*>(this);
    }
    else if (iid == IID_IY) {
        *ppv = static_cast<IY*>(this);
    }
    else {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
    reinterpret_cast<IUnknown*>(*ppv)->AddRef();
    return S_OK;
}

// NondelegatingAddRef 和 NondelegatingRelease 实现了引用计数管理
ULONG __stdcall CB::NondelegatingAddRef()
{
    return InterlockedIncrement(&m_cRef);
}

ULONG __stdcall CB::NondelegateRelease()
{
    if (InterlockedDecrement(&m_cRef) == 0) {
        delete this;
        return 0;
    }
    return m_cRef;
}

//
// Constructor
// 构造函数检查是否为聚合对象，决定委托的接口是外部接口还是内部的非委托接口
CB::CB(IUnknown* pUnknownOuter)
    : m_cRef(1)
{
    ::InterlockedIncrement(&g_cComponents);
	
	// pUnknownOuter 是一个指向外部 IUnknown 的指针，用于支持聚合。如果传入 NULL，说明该组件是非聚合的。
    if (pUnknownOuter == NULL) 
    {
        trace("Not aggregating: delegate to nondelegating IUnknown.不聚合:委托给非委托IUnknown。");
        // 在组件没有聚合时，将 m_pUnknownOuter 设置为指向当前对象的非委托 IUnknown 实现。
        m_pUnknownOuter = reinterpret_cast<IUnknown*>// 将其再转换为 IUnknown* 类型。尽管这两个类型都与 IUnknown 有关，二次转换是为了确保符合 IUnknown 的接口格式
            (static_cast<INondelegatingUnknown*> // 将 this 指针（当前对象）转换为 INondelegatingUnknown* 类型，即非委托的 IUnknown。
                (this));
    }
    // 在聚合模式下，组件将把所有的 IUnknown 方法（QueryInterface、AddRef、Release）委托给这个外部指针。
    else {
        trace("Aggregating: delegate to outer IUnknown.聚合:委托给外部IUnknown。");
        m_pUnknownOuter = pUnknownOuter; // 将 m_pUnknownOuter 设置为传入的 pUnknownOuter，即指向外部 IUnknown 的指针。
    }
}

// 
// Destructor
// 析构函数减少组件计数，并输出销毁信息
CB::~CB()
{
    InterlockedDecrement(&g_cComponents);
    trace("Destroy self.");
}

///
//
// Class factory
// 类工厂 CFactory
// CFactory 类实现了 IClassFactory 接口，负责创建组件实例
class CFactory : pubic IClassFactory
{
public:
    // IUnknown
    virtual HRESULT __stdcall QueryInterface(const IID& iid, void** ppv);
    virtual ULONG   __stdcall AddRef();
    virtual ULONG   __stdcall Release();

    // Interface IClassFactory 接口IClassFactory
    virtual HRESULT __stdcall CreateInstance(IUnknown* pUnknownOuter,
        const IID& iid,
        void** ppv);
    virtual HRESULT __stdcall LockServer(BOOL bLock);

    // Constructor
    CFactory() : m_cRef(1) {}

    // Destructor
    ~CFactory() {}

private:
    long m_cRef;
}

// 
// Class factory IUnknown implementation
// 实现了 IUnknown 接口，用于管理类工厂的生命周期
HRESULT CFactory::QueryInstance(const IID& iid, void** ppv)
{
    if ((iid == IID_IUnknown) || (iid == IID_IClassFactory)) {
        *ppv = static_cast<IClassFactory*>(this);
    }
    else {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
    reinterpret_cast<IUnknown*>(*ppv)->AddRef();
    return S_OK;
}

ULONG __stdcall CFactory::AddRef()
{
    return InterlockedIncremetn(&m_cRef);
}

ULONG __stdcall CFactory::Release()
{
    if (InterlockedDecrement(&m_cRef) == 0) {
        delete this;
        return 0;
    }
    return m_cRef;
}

//
// IClassFactory implementation
// IClassFactory 的实现
// CreateInstance 方法用于创建 CB 组件实例，并返回请求的接口。
HRESULT __stdcall CFactory::CreateInstance(IUnknown* pUnknownOuter,
    const IID& iid,
    void** ppv)
{
    // Aggregate only if the requested iid is IID_IUnknown.
    // 仅当请求的iid为IID_IUnknown时聚合。
    if ((pUnknownOuter != NULL) && (iid != IID_IUnknown)) {
        return CLASS_E_NOAGGREGATION;
    }

    // Create component.
    // 创建元件
    CB* pB = new CB(pUnknownOuter);
    if (pB == NULL) {
        return E_OUTOFMEMORY;
    }

    // Get the requested interface.
    // 获取所请求的接口。
    HRESULT hr = pB->NondelegatingQueryInterface(iid, ppv);
    pB->NondelegatingRelease();
    return hr;
}

// LockServer
// LockServer 方法管理 DLL 的加载和卸载控制
HRESULT CFactory::LockServer(BOOL bLock)
{
    if (bLock) 
    {
        InterlockedIncrement(&g_cServerLocks);
    }
    else {
        InterlockedDecrement(&g_cServerLocks);
    }
    return S_OK;
}

///
//
// Exported functions
// 输出功能
// 用于检查是否可以卸载 DLL。
STDAPI DllCanUnloadNow()
{
    if ((g_cComponents == 0) && (g_cServerLocks == 0)) {
        return S_OK;
    }
    else {
        return S_FALSE;
    }
}

//
// Get class factory.
// 获取类工厂
用于获取类工厂对象
STDAPI DllGetClassObject(const CLSID& clsid,
    const IID& iid,
    void** ppv)
{
    // Can we create this component?
    // 我们可以创建这个组件吗?
    if (clsid != CLSID_Component2) {
        return CLASS_E_CLASSNOTAVAILABLE;
    }

    // Create class factory.
    // 创建类工厂
    CFactory* pFactory = new CFactory;  // No AddRef in constructor
    if (pFactory == NULL) {
        return E_OUTOFMEMORY;
    }

    // Get requested interface.
    // 获取请求的接口。
    HRESULT hr = pFactory->QueryInterface(iid, ppv);
    pFactory->Release();

    return hr;
}

//
// Server registraton
// 用于组件的注册和注销
STDAPI DllRegisterServer()
{
    return RegisterServer(g_hModule,
        CLSID_Components2,
        g_szFriendlyName,
        g_szVerIndProgID,
        g_szProgID);
}
STDAPI DllUnregisterServer()
{
    return UnregisterServer(CLSID_Components2,
        g_szVerIndProgID,
        g_szProgID);
}

///
// 
// DLL module information
// DLL 的入口点，设置模块句柄，处理 DLL 加载和卸载事件
BOOL APIENTRY DllMain(HANDLE hModule,
    DWORD dwReason,
    void* lpReserved)
{
    if (dwReason == DLL_PROCESS_ATTACH) {
        g_hModule = hModule;
    }
    return TRUE;
}

在第五章的动态链接过后吗，就正式进入了COM组件的学习，因个人原因，并未详对学习过程进行详细记录
COM技术内幕所有学习笔记暂时完结
这是github中有前辈整理的COM技术内幕项目源码

系统架构设计师【第2章】: 计算机系统基础知识 (核心总结)
数据知道的博客
05-29 1万+
计算机系统 (Computer System)是指用于数据管理的计算机硬件、软件及网络组成的系统。它是按人的要求接收和存储信息，自动进行数据处理和计算， 并输出结果信息的机器系统。计算机系统可划分为硬件(子系统)和软件(子 系统)两部分。硬件由机械、电子元器件、磁介质和系统光介质等物理实体构成，例如处理器(含运算单元和 控制单元)、存储器、输入设备和输出设备等。软件是一系列按照特定顺序组织的数据和指令，并控制硬件完成指定的功能。可将计算机软件进一步分为系统软件和应用软件：系统软件。
架构师技能5：如何做code review 代码简洁之道
黄规速博客:学如逆水行舟，不进则退
01-15 2573
前言 CodeReview的目的是提升代码质量，尽早发现潜在缺陷与BUG，降低修复成本，同时促进团队内部知识共享，帮助更多人更好地理解系统。 如何做好code review，可以参考谷歌code review 指南。原文地址:https://google.github.io/eng-practices/review/reviewe code review从大的方面来说： 1、业务层面：业务逻辑是否正确等相关内容。例如 1）数据库字段的设计是否合理。 2）业务流程是否按............
第8章 组件复用：包容与聚合
jjunjoe的专栏
08-29 871
第8章 组件复用：包容与聚合 1、实现继承：指类继承其基类的代码或实现。 2、接口继承：指类继承其基类的类型或接口。 3、COM不支持实现继承，但COM支持接口继承。因为对于实现继承，当基类的实现被修改之后，派生类将无法正常运行而必须被修改，为了保证对组件的修改不会影响应用
COM技术内幕学习笔记---第八章---组件复用：包容和聚合
shb8845369的专栏
04-08 2020
COM 不支持实现继承的原因在于这种继承方式将 使得一个对象的实现同另外一个对象的实现紧紧地关联起来。 在这种情况下，当基类的实现被修改之后，派生类将无法正常运行而必须被修改。对于一个中等规模的C++程序而言，这或许并不成为一个问题，因在这种情况下，我们一般能够获取所有的源代码，因此也将能够对派生类进行修改。但是对于较大的C++程序而言，对受影响的派生类进行修改所花费的时间将是相当长的。更糟的是
实现领域驱动设计（DDD）系列详解：如何设计聚合
晓风残月淡的博客
03-20 2159
前面第二次迭代完成，就该实际完成业务逻辑了。 1.聚合根的设计 聚合根是主要的业务逻辑载体，DDD中所有的战术实现都围绕着聚合根展开。 一个大而全的聚合根可以囊括所有业务逻辑，这前景很诱人，但是却不合适，易造成并发风险。 例如,一篇博客包括标题、内容、作者、标签、评论等。 public class Blog{ private BlogId blogId; private String title; private Author author; private Post pos
软件工程理论与实践第8期-7 面向对象设计
qq_62174885的博客
04-02 2368
本章的目标是使学生理解面向对象设计原则，掌握架构设计要点，掌握用面向对象方法进行系统设计的方法。能够提交设计模型文档，包括架构设计方案、关键构件和关键类的详细设计。具体的，本章通过具体案例的讨论、分析、设计和实现，使学生将理论应用于实践，加强学生对实际问题的分析和解决能力，以及团体协作和项目管理能力。
【高项】第五章 信息系统工程
LYX_WIN
05-04 1156
信息安全系统工程就是要建造一个信息安全系统，它是整个信息系统工程的一部分，而且最好是与业务应用信息系统工程同步进行，主要围绕“信息安全“内容，如信息安全风险评估、信息安全策略制定、信息安全需求确定、信息安全系统总体设计、信息安全系统详细设计、信息安全系统设备选型、信息安全系统工程招投标、密钥密码机制确定、资源界定和投权、信息安全系统施工中需要注意防泄密问题和施工中后期的信息安全系统割试、运营、维护的安全管理等问题。业务应用信息系统工程所主要关注的是客户的需求、业务流程、价值链等组织的业务优化和改造的问题。
系统集成|第三章(笔记)
xhmico的博客
07-25 1266
上篇： 第二章、信息系统服务管理 生命周期：开发方法：项目开发过程：： 概述：是指将计算机软件、硬件、网络通信等技术产品集成为能够满足用户特定需求的信息系统，是一项综合性的系统工程。信息系统集成包括计算机应用系统工程和网络系统工程的总体策划、设计、开发、实施、服务及保障等方方面面。生命周期：分类：：信息系统集成项目： 方案设计包括： 和 系统架构：是将系统整体分解为更小的子系统和组件，从而形成不同的逻辑层或服务。设备、DBMS 及技术选型： 软件需求：软件的生命周期：软件设计组成包括：视图包括：软件测试：：
COM技术内幕——微软组件对象模型--随书源代码
09-18
第8章 组件复用：包容与聚合 125 8.1 包容和聚合 126 8.1.1 包容简介 126 8.1.2 聚合简介 127 8.1.3 包容与聚合的比较 127 8.2 包容的实现 128 8.2.1 接口扩展 131 8.3 聚合的实现 132 8.3.1 QueryInterface...
第五章 信息系统工程
魏宇轩
03-22 960
X 轴是“安全机制”。安全机制可以理解为提供某些安全服务，利用各种安全技术和技巧，所形成的一个较为完善的结构体系。如“平台安全”机制，实际上就是指安全操作系统、安全数据库、应用开发运营的安全平台以及网络安全管理监控系统等。Y 轴是“OSI网络参考模型”。信息安全系统的许多技术、技巧都是在网络的各个层面上实施的，离开网络信息系统的安全也就失去意义。Z 轴是“安全服务”。安全服务就是从网络中的各个层次提供给信息应用系统所需要的安全服务支持。如对等实体认证服务、访问控制服务、数据保密服务等。
精通MFC （光盘） 源代码
10-05
第8章 对话框 8.1 对话框的生存期 8.1.1 对话框的创建 8.1.2 对话框的初始化 8.1.3 对话框的消息处理 8.1.4 对话框的结束 8.2 数据交换和数据验证 8.3 使用通用对话框 8.3.1 基本用法 8.3.2 定制通用...
YOLOv8-PyQt5-GUI-pred-insects-mytwu-995识别和分类昆虫种类-检测生态研究和害虫防治+数据集+训练好的模型.zip
05-27
YOLOv8-PyQt5-GUI-pred-insects-mytwu_995识别和分类昆虫种类-检测生态研究和害虫防治+数据集+训练好的模型包含pyqt可视化界面，有使用教程 1. 内部包含标注好的目标检测数据集，分别有yolo格式(txt文件)和voc格式标签(xml文件), 共995张图像， 已划分好数据集train，val, test，并附有data.yaml文件可直接用于yolov5,v8,v9,v10,v11,v12等算法的训练； 2. yolo目标检测数据集类别名：insects（昆虫），包括 army_worm（行军虫）、legume_blister_beetle（豆类起泡叶甲）、red_spider（红蜘蛛）、rice_gall_midge（水稻瘿蚊）、rice_leaf_roller（水稻卷叶螟）、rice_leafhopper（水稻飞虱）、rice_water_weevil（水稻水象甲）、wheat_phloeothrips（小麦皮层蓟马）、white_backed_plant_hopper（白背飞虱）、yellow_rice_borer（水稻二化螟）等 3. yolo项目用途：识别和分类昆虫种类，用于生态研究和害虫防治 4. 可视化参考链接：https://blog.youkuaiyun.com/weixin_51154380/article/details/126395695?spm=1001.2014.3001.5502
在Matlab_Simulink中使用3D动画的帆船模型仿真.rar
05-27
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
MATLAB函数曲线图像数据提取与重绘：快速高效的数据可视化解决方案
05-27
内容概要：本文详细介绍了如何利用MATLAB进行函数曲线图像的数据提取、复现重绘及后处理的方法。主要内容涵盖数据准备与导入、数据提取与预处理、图像复现与重绘、图像修改与后处理四个主要阶段。文中强调了程序编写的清晰性和注释的详尽性，确保即使是不熟悉MATLAB编程的用户也能快速理解和修改代码。此外，本文特别指出该服务不含曲线拟合、公式提取及FFT频谱分析等高级分析功能，但能在10分钟内快速出图，提供实惠的价格和服务质量。 适合人群：科研人员、工程师及其他需要进行数据可视化工作的专业人士，尤其是那些希望快速掌握MATLAB绘图技巧的新手。 使用场景及目标：适用于需要将原始图像数据转换为高质量函数曲线图像的各种应用场景，如实验数据分析、工程报告制作等。目标是在短时间内获得精确、美观的图表，同时提高工作效率。 其他说明：本文提供的方法和技术可以帮助用户更好地理解和应用MATLAB的基础绘图功能，为进一步深入学习打下坚实基础。虽然目前不涉及复杂的数学建模或信号处理技术，但对于大多数日常的数据可视化任务来说已经足够强大。
移动通信复习资料全部答案.docx
05-27
移动通信复习资料全部答案.docx
自动驾驶领域Lanelet2高精地图解析与全局路径规划实战指南
05-27
内容概要：本文详细介绍了Lanelet2高精地图的解析方法及其在全球路径规划中的应用。首先解释了Lanelet2作为当前主流高精度地图格式之一的特点，特别是它对车道、交通规则等元素的数据结构化表示方式。接着展示了如何利用Python和C++代码片段来加载和处理Lanelet2格式的地图，包括正确设置投影参数、遍历车道以及处理特定类型的车道（如左转车道）。然后深入探讨了全局路径规划的具体实现步骤，强调了选择合适搜索半径的重要性，并分享了一些实际项目中遇到的问题及解决方案，如坐标系转换错误导致的地图偏移、断头路引发的死循环等问题。最后提醒开发者注意地图制作过程中的常见陷阱，建议使用手动可视化工具进行细致检查。 适用人群：从事自动驾驶相关领域的工程师和技术爱好者，尤其是那些需要理解和使用Lanelet2高精地图进行开发的人群。 使用场景及目标：帮助读者掌握Lanelet2高精地图的基本概念和关键技术点，能够独立完成从地图加载到全局路径规划的一系列任务，避免常见的开发误区。 其他说明：文中提供的实例代码和实践经验对于初学者来说非常有价值，有助于快速入门并应用于实际项目中。
第3章客户关系管理软件系统.ppt
05-27
第3章客户关系管理软件系统.ppt
GD32F303CCT6-LED点灯
最新发布
05-27
使用GD32F303芯片作为主控MCU，通过PB3输出1秒周期的高低电平点亮LED灯
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值