C++ 简单DirectX 11程序运行时错误

我是DirectX 11的新手，我已经设法在我的书中获得了绘制三角形的章节。 我已经编写了这段代码，但出现了一个运行时错误： “DirectX 11.exe中0x00cd14e6处未处理的异常：0xc0000005:访问冲突读取位置0x00000000。”

我的编译器显示错误在InitPipeline函数中，但我在那里找不到错误。 我做错了什么

代码：

#包括
#包括
#包括
#包括
#包括
#pragma注释（lib，“d3d11.lib”）
#pragma注释（lib，“d3dx11.lib”）
#pragma注释（lib，“d3dx10.lib”）
#定义屏幕宽度800
#定义屏幕高度600
IDXGISwapChain*swapchain；
ID3D11设备*dev；
ID3D11DeviceContext*devcon；
ID3D11InputLayout*pInputLayout；
ID3D11Buffer*pVBuffer；
ID3D11RenderTargetView*backbuffer；
ID3D11VertexShader*pVS；
ID3D11PixelShader*pPS；
//类型
结构顶点
{
浮动X，Y，Z；
d3dx颜色；
};
//DirectX
void InitPipeline（）
{
//加载并编译两个着色器
ID3D10Blob*VS，*PS；
D3DX11CompileFromFile（“shaders.hlsl”、0、0、“VShader”、“vs_5_0”、0、0、0和vs、0、0）；
D3DX11CompileFromFile（“shaders.hlsl”、0、0、“PShader”、“ps_5_0”、0、0、0和ps、0、0）；
//调试
如果（！dev）
{
MessageBox（NULL，“DEV=NULL”，“ERROR”，NULL）；
}
如果（！devcon）
{
MessageBox（NULL，“DEVCON=NULL”，“ERROR”，NULL）；
}
如果（！VS）
{
MessageBox（NULL，“VS=NULL”，“ERROR”，NULL）；
}
如果（！PS）
{
消息框（NULL，“PS=NULL”，“错误”，NULL）；
}
//将两个着色器封装到着色器对象中
dev->CreateVertexShader（VS->GetBufferPointer（），VS->GetBufferSize（），NULL，&pVS）；
dev->CreatePixelShader（PS->GetBufferPointer（），PS->GetBufferSize（），NULL，&pPS）；
//设置着色器对象
devcon->VSSetShader（pVS，0，0）；
devcon->PSSetShader（pPS，0，0）；
D3D11输入元素描述[]=
{
{“位置”，0，DXGI_格式_R32G32B32_浮点，0,0，D3D11_输入_逐顶点_数据，0}，
{“COLOR”，0，DXGI_FORMAT_R32G32B32A32_FLOAT，0，D3D11_APPEND_ALIGNED_元素，D3D11_INPUT_PER_VERTEX_DATA，0}，
};
dev->CreateInputLayout（ied、2、VS->GetBufferPointer（）、VS->GetBufferSize（）、和pInputLayout）；
devcon->iSetInputLayout（pInputLayout）；
}
void InitGraphics（）
{
顶点或顶点[]=
{
{1,0,0，D3DXCOLOR（1,0,0,1）}，
{0，-1,0，D3DXCOLOR（1,0,0,1）}，
{0,0,1，D3DXCOLOR（1,0,0,1）}，
};
D3D11_BUFFER_DESC bd；
零内存（&bd，sizeof（D3D11_BUFFER_DESC））；
bd.BindFlags=D3D11_BIND_VERTEX_BUFFER；
bd.ByteWidth=sizeof（顶点）*3；
bd.CPUAccessFlags=D3D11\u CPU\u访问\u写入；
bd.用法=D3D11\u用法\u动态；
dev->CreateBuffer（&bd、NULL和&pVBuffer）；
D3D11_映射_子资源ms；
devcon->Map（pVBuffer、NULL、D3D11\u Map\u WRITE\u DISCARD、NULL和ms）；
memcpy（ms.pData、OurVertices、sizeof（OurVertices））；
devcon->Unmap（pVBuffer，NULL）；
}
void RenderFrame（）
{
devcon->ClearRenderTargetView（backbuffer，D3DXCOLOR（0,0,1,1））；
UINT步幅=尺寸（顶点）；
UINT偏移=0；
devcon->IASetVertexBuffers（0、1、pVBuffer、跨步和偏移）；
devcon->iSetPrimitiveTopology（D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST）；
devcon->Draw（3,0）；
交换链->当前（0,0）；
}
无效初始D3D（HWND HWND）
{
//创建一个结构以保存有关交换链的信息
DXGI交换链描述scd；
//清除结构以供使用
零内存（&scd，sizeof（DXGI_-SWAP_-CHAIN_-DESC））；
//填写交换链描述结构
scd.BufferCount=1；//一个后台缓冲区
scd.BufferDesc.Format=DXGI_Format_R8G8B8A8_UNORM；//使用32位颜色
scd.BufferDesc.Width=屏幕宽度；//设置后缓冲区宽度
scd.BufferDesc.Height=屏幕高度；//设置后缓冲区高度
scd.BufferUsage=DXGI\u USAGE\u RENDER\u TARGET\u OUTPUT；//如何使用交换链
scd.OutputWindow=hWnd；//要使用的窗口
scd.SampleDesc.Count=4；//有多少个多样本
scd.Windowed=TRUE；//窗口/全屏模式
scd.Flags=DXGI\u SWAP\u CHAIN\u FLAG\u ALLOW\u MODE\u SWITCH；//允许全屏切换
//使用scd结构中的信息创建设备、设备上下文和交换链
如果（失败）（D3D11CreateDeviceAndSwapChain（空，
D3D_驱动器_类型_硬件，
无效的
无效的
无效的
无效的
D3D11_SDK_版本，
&scd，
&swapchain，
&德夫，
无效的
&devcon）
{
MessageBox（空，“D3D11CreateDeviceAndSwapChain失败”，“错误”，空）；
}
//获取后台缓冲区的地址
ID3D11Texture2D*pBackBuffer；
swapchain->GetBuffer（0，u_uidof（ID3D11Texture2D），（LPVOID*）和pBackBuffer）；
//使用后缓冲区地址创建渲染目标
dev->CreateRenderTargetView（pBackBuffer、NULL和backbuffer）；
pBackBuffer->Release（）；
//将渲染目标设置为后缓冲区
devcon->OMSetRenderTargets（1，&Backuffer，NULL）；
//设置视口
D3D11_视口；
ZeroMemory（&视口，sizeof（D3D11_视口））；
viewport.TopLeftX=0；
viewport.TopLeftY=0；
viewport.Width=屏幕宽度；
viewport.Height=屏幕高度；
devcon->rssetviewport（1和视口）；
InitPipeline（）；
InitGraphics（）；
}
void CleanD3D（）
{
swapchain->SetFullscreenState（FALSE，NULL）；
发展
    #include <windows.h>
#include <windowsx.h>

#include <d3d11.h>
#include <D3DX11.h>
#include <D3DX10.h>

#pragma comment(lib,"d3d11.lib")
#pragma comment(lib,"d3dx11.lib")
#pragma comment(lib,"d3dx10.lib")

#define SCREEN_WIDTH 800
#define SCREEN_HEIGHT 600

IDXGISwapChain                  *swapchain;
ID3D11Device                    *dev;
ID3D11DeviceContext             *devcon;

ID3D11InputLayout               *pInputLayout;
ID3D11Buffer                    *pVBuffer;
ID3D11RenderTargetView          *backbuffer;
ID3D11VertexShader              *pVS;
ID3D11PixelShader               *pPS;

// Type
struct VERTEX
{
    FLOAT X,Y,Z;
    D3DXCOLOR Color;
};
//DirectX
void InitPipeline()
{
    // load and compile the two shaders
     ID3D10Blob *VS, *PS;
     D3DX11CompileFromFile("shaders.hlsl", 0, 0, "VShader", "vs_5_0", 0, 0, 0, &VS, 0, 0);
     D3DX11CompileFromFile("shaders.hlsl", 0, 0, "PShader", "ps_5_0", 0, 0, 0, &PS, 0, 0);

     //debug
     if(!dev)
     {
         MessageBox(NULL, "DEV = NULL", "ERROR", NULL);
     }
     if(!devcon)
     {
         MessageBox(NULL, "DEVCON = NULL", "ERROR", NULL);
     }

     if(!VS)
     {
         MessageBox(NULL, "VS = NULL", "ERROR", NULL);
     }
     if(!PS)
     {
         MessageBox(NULL, "PS = NULL", "ERROR", NULL);
     }
     // encapsulate both shaders into shader objects
     dev->CreateVertexShader(VS->GetBufferPointer(), VS->GetBufferSize(), NULL, &pVS);
     dev->CreatePixelShader(PS->GetBufferPointer(), PS->GetBufferSize(), NULL, &pPS);

     // set the shader objects
     devcon->VSSetShader(pVS, 0, 0);
     devcon->PSSetShader(pPS, 0, 0);

    D3D11_INPUT_ELEMENT_DESC ied[] =
    {
        {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0,0,D3D11_INPUT_PER_VERTEX_DATA,0},
        {"COLOR",0,DXGI_FORMAT_R32G32B32A32_FLOAT,0,D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0},
    };

    dev->CreateInputLayout(ied, 2, VS->GetBufferPointer(), VS->GetBufferSize(), &pInputLayout);
    devcon->IASetInputLayout(pInputLayout);
}


void InitGraphics()
{
    VERTEX OurVertices[] =
    {
        {1,0,0,D3DXCOLOR(1,0,0,1)},
        {0,-1,0,D3DXCOLOR(1,0,0,1)},
        {0,0,1,D3DXCOLOR(1,0,0,1)},
    };

    D3D11_BUFFER_DESC bd;
    ZeroMemory(&bd, sizeof(D3D11_BUFFER_DESC));
    bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    bd.ByteWidth = sizeof(VERTEX)*3;
    bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    bd.Usage = D3D11_USAGE_DYNAMIC;

    dev->CreateBuffer(&bd, NULL, &pVBuffer);

    D3D11_MAPPED_SUBRESOURCE ms;
    devcon->Map(pVBuffer, NULL, D3D11_MAP_WRITE_DISCARD, NULL, &ms);
    memcpy(ms.pData, OurVertices, sizeof(OurVertices));
    devcon->Unmap(pVBuffer, NULL);
}
void RenderFrame()
{
    devcon->ClearRenderTargetView(backbuffer, D3DXCOLOR(0,0,1,1));

    UINT stride = sizeof(VERTEX);
    UINT offset = 0;
    devcon->IASetVertexBuffers(0, 1, &pVBuffer, &stride, &offset);
    devcon->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
    devcon->Draw(3,0);

    swapchain->Present(0,0);
}
void InitD3D(HWND hWnd)
 {
     // create a struct to hold information about the swap chain
     DXGI_SWAP_CHAIN_DESC scd;

     // clear out the struct for use
     ZeroMemory(&scd, sizeof(DXGI_SWAP_CHAIN_DESC));

     // fill the swap chain description struct
     scd.BufferCount = 1;                                   // one back buffer
     scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;    // use 32-bit color
     scd.BufferDesc.Width = SCREEN_WIDTH;                   // set the back buffer width
     scd.BufferDesc.Height = SCREEN_HEIGHT;                 // set the back buffer height
     scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;     // how swap chain is to be used
     scd.OutputWindow = hWnd;                               // the window to be used
     scd.SampleDesc.Count = 4;                              // how many multisamples
     scd.Windowed = TRUE;                                   // windowed/full-screen mode
     scd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;    // allow full-screen switching

     // create a device, device context and swap chain using the information in the scd struct
     if(FAILED(D3D11CreateDeviceAndSwapChain(NULL,
                                   D3D_DRIVER_TYPE_HARDWARE,
                                   NULL,
                                   NULL,
                                   NULL,
                                   NULL,
                                   D3D11_SDK_VERSION,
                                   &scd,
                                   &swapchain,
                                   &dev,
                                   NULL,
                                   &devcon)))
     {
         MessageBox(NULL, "D3D11CreateDeviceAndSwapChain Failed", "ERROR", NULL);
     }




     // get the address of the back buffer
     ID3D11Texture2D *pBackBuffer;
     swapchain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer);

     // use the back buffer address to create the render target
     dev->CreateRenderTargetView(pBackBuffer, NULL, &backbuffer);
     pBackBuffer->Release();

     // set the render target as the back buffer
     devcon->OMSetRenderTargets(1, &backbuffer, NULL);


     // Set the viewport
     D3D11_VIEWPORT viewport;
     ZeroMemory(&viewport, sizeof(D3D11_VIEWPORT));

     viewport.TopLeftX = 0;
     viewport.TopLeftY = 0;
     viewport.Width = SCREEN_WIDTH;
     viewport.Height = SCREEN_HEIGHT;

     devcon->RSSetViewports(1, &viewport);

    InitPipeline();
     InitGraphics();
 }
void CleanD3D()
{
    swapchain->SetFullscreenState(FALSE, NULL);
    dev->Release();
    devcon->Release();
    swapchain->Release();
    pInputLayout->Release();
    pVBuffer->Release();
    backbuffer->Release();
    pVS->Release();
    pPS->Release();
}

// Window
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch(message)
    {
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
}
INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, INT nCmdShow)
{
    HWND hWnd;

    WNDCLASSEX wc;
    ZeroMemory(&wc, sizeof(WNDCLASSEX));
    wc.cbSize = sizeof(WNDCLASSEX);
    //wc.hbrBackground = (HBRUSH)GetStockObject(GRAY_BRUSH);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hIcon = (HICON)LoadIcon(NULL, IDI_APPLICATION);
    wc.hInstance = hInstance;
    wc.lpfnWndProc = WndProc;
    wc.lpszClassName = "DirectXWindow";
    wc.style = CS_HREDRAW | CS_VREDRAW;

    RegisterClassEx(&wc);

    hWnd = CreateWindowEx(NULL,
        "DirectXWindow",
        "DirectX 11 (June 2010",
        WS_OVERLAPPEDWINDOW,
        0,0,
        SCREEN_WIDTH, SCREEN_HEIGHT,
        NULL,
        NULL,
        hInstance,
        NULL);

    ShowWindow(hWnd, nCmdShow);

    InitD3D(hWnd);
    UpdateWindow(hWnd);

    MSG msg = {0};

    while(msg.message != WM_QUIT)
    {
        if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);

        }
        else
        {
            RenderFrame();
        }
    }
    CleanD3D();

    return msg.wParam;
}