Расширение динамически созданного массива объектов

//***************************************************************************
// indexbufferclass.h
//
//***************************************************************************
#pragma once
#ifndef INDEXBUFFERCLASS_H
#define INDEXBUFFERCLASS_H
 
#include "..\\logclass.h"
 
class IndexBufferClass
{
public:
    IndexBufferClass(ID3D11Device*, LogClass*);
    bool Initialize(int);
    ID3D11Buffer* GetIndexBuffer();
    int GetCountIndex();
    void Shutdown();
private:
    ID3D11Buffer* m_indexBuffer;
    int m_countIndex;
 
    ID3D11Device* m_device;
    LogClass* m_Log;
};
 
#endif
 
 
//***************************************************************************
// indexbufferclass.cpp
//
//***************************************************************************
#include "indexbufferclass.h"
 
IndexBufferClass::IndexBufferClass(ID3D11Device* device, LogClass* Log)
{
    m_device = device;
    m_Log = Log;
}
 
bool IndexBufferClass::Initialize( int countIndex)
{
    HRESULT hr;
    unsigned long* indices;
    D3D11_BUFFER_DESC indexBufferDesc;
    D3D11_SUBRESOURCE_DATA indexData;
 
    m_countIndex = countIndex;
 
    indices = new unsigned long[countIndex];
    for (int i = 0; i < countIndex; i++)
    {
        indices[i] = i;
    }
 
    indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    indexBufferDesc.ByteWidth = sizeof(unsigned long) * countIndex;
    indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
    indexBufferDesc.CPUAccessFlags = 0;
    indexBufferDesc.MiscFlags = 0;
    indexBufferDesc.StructureByteStride = 0;
 
 
    indexData.pSysMem = indices;
    indexData.SysMemPitch = 0;
    indexData.SysMemSlicePitch = 0;
 
    hr = m_device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer);
    if (FAILED(hr))
    {
        m_Log->Write(1, "Error", "Buffer not сreated", "indexbufferclass.cpp");
        return false;
    }
 
    delete[] indices;
    indices = 0;
 
    return true;
}
 
ID3D11Buffer* IndexBufferClass::GetIndexBuffer()
{
    return m_indexBuffer;
}
 
int IndexBufferClass::GetCountIndex()
{
    return m_countIndex;
}
 
void IndexBufferClass::Shutdown()
{
    if (m_indexBuffer)
    {
        m_indexBuffer->Release();
    }
}
 
//***************************************************************************
// managerresourceclass.h
//
//***************************************************************************
#pragma once
#ifndef MANAGERRESOURCECLASS_H
#define MANAGERRESOURCECLASS_H
 
#include "logclass.h"
#include "Resource\indexbufferclass.h"
 
class ManagerResourceClass
{
public:
    enum ResourceType
    {
        INDEX_BUFFER = 0
    };
public:
    ManagerResourceClass(ID3D11Device*, ID3D11DeviceContext*, HWND*, LogClass*);
    bool InitData(ResourceType, int);
    void Shutdown();
 
    template< typename T > void CreateData(T**&, ResourceType, int);
 
    IndexBufferClass* GetIndexBuffer(int);
private:
    ID3D11Device* m_device;
    ID3D11DeviceContext* m_deviceContext;
    LogClass* m_Log;
    HWND* m_hWnd;
    int m_countResource;
 
    int* m_countData;
    IndexBufferClass** m_IndexBuffer;
};
 
#endif
 
 
 
//***************************************************************************
// managerresourceclass.cpp
//
//***************************************************************************
#include "managerresourceclass.h"
 
template< typename T >
void ManagerResourceClass::CreateData(T **&object, ResourceType resource, int countData)
{
    if (m_countData[resource] == 0)
    {
        m_countData[resource] = countData;
        object = new T*[countData];
        for (int i = 0; i < countData; i++)
        {
                object[i] = new T(m_device, m_Log);
        }
    }
    else
    {
        ReallocInt(object, m_countData[resource], countData);
        for (int i = m_countData[resource]; i < countData; i++)
        {
                object[i] = new T(m_device, m_Log);
        }
        m_countData[resource] = countData;
    }
}
 
ManagerResourceClass::ManagerResourceClass(ID3D11Device* device, ID3D11DeviceContext* deviceContext, HWND* hWnd, LogClass* Log)
{
    m_device = device;
    m_deviceContext = deviceContext;
    m_Log = Log;
    m_hWnd = hWnd;
    m_countResource = 1;
    m_countData = new int[m_countResource];
    for (int i = 0; i < m_countResource; i++)
        m_countData[i] = 0;
}
 
bool ManagerResourceClass::InitData(ResourceType resource, int countData)
{
    if (countData == 0)
    {
        m_Log->Write(1, "UsersError", "The number of created objects should not be 0!", "Replace the 0 to a positive integer (x > 0).", "main.cpp");
        return false;
    }
 
    if (resource == INDEX_BUFFER)
    {
        CreateData(m_IndexBuffer, INDEX_BUFFER, countData);
    }
    else
    {
        m_Log->Write(1, "UsersError", "Resource name is incorrect!", "Replace the name to a name from ResourceType list.", "main.cpp");
        return false;
    }
    
    return true;
}
 
IndexBufferClass* ManagerResourceClass::GetIndexBuffer(int num)
{
    return m_IndexBuffer[num];
}
 
PictureClass* ManagerResourceClass::GetPicture(int num)
{
    return m_Picture[num];
}
 
void ManagerResourceClass::Shutdown()
{
    if (m_IndexBuffer)
    {
        for (int i = 0; i < m_countData[INDEX_BUFFER]; i++)
        {
            m_IndexBuffer[i]->Shutdown();
            delete[] m_IndexBuffer[i];
        }
    }
    delete[] m_IndexBuffer;
 
    delete[] m_countData;
}
 
.....
 
//***************************************************************************
// functionclass.h
//
//***************************************************************************
#pragma once
#ifndef FUNCTIONCLASS_H
#define FUNCTIONCLASS_H
 
 
template< typename T >
void ReallocInt(T **&arr, int size, int new_size)
{
    T **new_arr = new T*[new_size];
    //size = size < new_size ? size : new_size;
 
    for (int i = 0; i < size; ++i)
    {
        new_arr[i] = arr[i];
    }
    
    delete[] arr;
 
    arr = new_arr;
}
 
#endif
......
 
 
 
 
main.cpp 
 
 
.....
 
ManagerResourceClass* m_ManagerResource; 
IndexBufferClass* m_IndexBuffer;
 
m_ManagerResource = new ManagerResourceClass(m_device, m_deviceContext, &m_hWnd, m_Log);
m_ManagerResource->InitData(ManagerResourceClass::ResourceType::INDEX_BUFFER, 1);
m_IndexBuffer = m_ManagerResource->GetIndexBuffer(0);
result = m_IndexBuffer->Initialize(6);
if (result == false)
{
    return false;
}
 
 
 
m_ManagerResource->Shutdown();
delete m_ManagerResource;
 
.....