non può convertire 'LPCWSTR {aka const wchar_t *}' in 'LPCSTR {aka const char *}

Question

Ho cercato di ottenere Glew e opengl 3.2 lavorando con blocchi di codice (minGW) in un contesto win32. ho trovato un piccolo tutorial here

Come stavo cercando di capire se compilare glew in codeblocks fosse effettivamente possibile, volevo provare l'origine prima di fare il tutorial per vedere se avrebbe funzionato.

dopo aver modificato leggermente il codice, ho provato a compilare e ho ottenuto diversi errori che non avevo mai visto prima. sono come segue

|In function 'bool createWindow(LPCWSTR, int, int)':| 
|73|error: cannot convert 'LPCWSTR {aka const wchar_t*}' to 'LPCSTR {aka const char*}' in assignment| 
|80|error: cannot convert 'LPCWSTR {aka const wchar_t*}' to 'LPCSTR {aka const char*}' for argument '2' to 'HWND__* CreateWindowExA(DWORD, LPCSTR, LPCSTR, DWORD, int, int, int, int, HWND, HMENU, HINSTANCE, LPVOID)'| 
|In function 'int WinMain(HINSTANCE, HINSTANCE, LPSTR, int)':| 
|105|warning: deprecated conversion from string constant to 'char*' [-Wwrite-strings]| 
|110|error: '_TRUNCATE' was not declared in this scope| 
|110|error: 'mbstowcs_s' was not declared in this scope| 

mio codice è

include <iostream> 
#include <Windows.h> 

#ifndef GLEW_STATIC 
#define GLEW_STATIC 
#endif //GLEW_STATIC 



#include <GL/glew.h> 
#include <GL/wglew.h> 

//using namespace std; 
// 
//int main() 
//{ 
// cout << "Hello world!" << endl; 
// return 0; 
//} 


#include "opengl_3.h" 

OpenGLContext openglContext; // Our OpenGL Context class 

bool running = true; // Whether or not the application is currently running 

HINSTANCE hInstance; // The HINSTANCE of this application 
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Standard window callback 

/** 
    WndProc is a standard method used in Win32 programming for handling Window messages. Here we 
    handle our window resizing and tell our OpenGLContext the new window size. 
*/ 
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) { 
    switch (message) { 
     case WM_SIZE: // If our window is resizing 
     { 
      openglContext.reshapeWindow(LOWORD(lParam), HIWORD(lParam)); // Send the new window size to our OpenGLContext 
      break; 
     } 

     case WM_DESTROY: 
     { 
      PostQuitMessage(0); 
      break; 
     } 
    } 

    return DefWindowProc(hWnd, message, wParam, lParam); 
} 

/** 
    createWindow is going to create our window using Windows API calls. It is then going to 
    create our OpenGL context on the window and then show our window, making it visible. 
*/ 
bool createWindow(LPCWSTR title, int width, int height) { 
    WNDCLASS windowClass; 
    HWND hWnd; 
    DWORD dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; 

    hInstance = GetModuleHandle(NULL); 

    windowClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; 
    windowClass.lpfnWndProc = (WNDPROC) WndProc; 
    windowClass.cbClsExtra = 0; 
    windowClass.cbWndExtra = 0; 
    windowClass.hInstance = hInstance; 
    windowClass.hIcon = LoadIcon(NULL, IDI_WINLOGO); 
    windowClass.hCursor = LoadCursor(NULL, IDC_ARROW); 
    windowClass.hbrBackground = NULL; 
    windowClass.lpszMenuName = NULL; 
    windowClass.lpszClassName = title; 

    if (!RegisterClass(&windowClass)) { 
     return false; 
    } 

    hWnd = CreateWindowEx(dwExStyle, title, title, WS_OVERLAPPEDWINDOW, 
     CW_USEDEFAULT, 0, width, height, NULL, NULL, hInstance, NULL); 

    openglContext.create30Context(hWnd); // Create our OpenGL context on the given window we just created 

    ShowWindow(hWnd, SW_SHOW); 
    UpdateWindow(hWnd); 

    return true; 
} 

/** 
    WinMain is the main entry point for Windows based applications as opposed to 'main' for console 
    applications. Here we will make the calls to create our window, setup our scene and then 
    perform our 'infinite' loop which processes messages and renders. 
*/ 
int WINAPI WinMain(HINSTANCE hInstance, 
        HINSTANCE hPrevInstance, 
        LPSTR lpCmdLine, 
        int  nCmdShow) { 
    MSG msg; 

    /** 
     The following 6 lines of code do conversion between char arrays and LPCWSTR variables 
     which are used in the Windows API. 
    */ 
    char *orig = "OpenGL 3 Project"; // Our windows title 
    size_t origsize = strlen(orig) + 1; 
    const size_t newsize = 100; 
    size_t convertedChars = 0; 
    wchar_t wcstring[newsize]; 
    mbstowcs_s(&convertedChars, wcstring, origsize, orig, _TRUNCATE); 

    createWindow(wcstring, 500, 500); // Create our OpenGL window 

    openglContext.setupScene(); // Setup our OpenGL scene 

    /** 
     This is our main loop, it continues for as long as running is true 
    */ 
    while (running) 
    { 
     if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { // If we have a message to process, process it 
      if (msg.message == WM_QUIT) { 
       running = false; // Set running to false if we have a message to quit 
      } 
      else { 
       TranslateMessage(&msg); 
       DispatchMessage(&msg); 
      } 
     } 
     else { // If we don't have a message to process 
      openglContext.renderScene(); // Render our scene (which also handles swapping of buffers) 
     } 
    } 

    return (int) msg.wParam; 
} 

(Ci scusiamo per il muro di testo) ci sono anche altri file, ma tutti gli errori sembrano diventare da qui. post malato il resto se necessario.

Non ho visto alcun errore simile a questo, quindi ho fatto qualche ricerca su google e ho scoperto che l'errore era causato dal fatto che il compilatore non era impostato su multi-byte (un'impostazione in VS2010). ho fatto un po 'di guardarmi intorno e non sono riuscito a trovare alcuna impostazione di questo tipo nei codici. questo codice è utilizzabile solo in VS o mi è sfuggito qualcosa? sono preoccupato che potrebbe essere qualcosa a che fare con il mio collegamento a causa di me avere un sacco di problemi con questo in passato. Qualsiasi aiuto sarebbe apprezzato.

Answer 1

Modificare CreateWindowEx a CreateWindowExW o definire la macro UNICODE prima di includere eventuali intestazioni.

Answer 2

Non ho mai usato minGW, quindi prendi questo con un granello di sale. (VS Express è gratuito, BTW.)

La decisione Unicode/Ascii è ampiamente controllata dalla definizione UNICODE. Quindi, se #define UNICODE 1, o eventualmente lo invii sulla riga di comando della compilazione, ci sono buone probabilità che possa risolvere il tuo problema.