Hola, muy buenas. Me gustaría saber como obtener una lista de archivos y carpetas dado un directorio en cualquier sistema operativo. Si es posible, me gustaría almacenar esta información en una variable de tipo char **.

Muchas gracias

Vale, muchas gracias!

Vale, funciona. Pero lo que era constante no era el puntero? Es decir, la dirección es constante y lo que es apuntado se puede modificar? O al revés? Gracias

Hola, muy buenas a tod@s. Me estoy desesperando con Visual Studio 12.0 Express. El error se resume en un código muy simple:

int main() {
	const char *code;
	code = new char[2];
	code[0] = 'a'; // Aquí está el error
 
        return 0;
}

Como ven, primero creo una cadena de caracteres. Por consiguiente, la inicializo con el operador new. Y por último, el lugar donde está el error. El error según Visual Studio dice así: "Error: La expresión debe ser un valor L modificable". También he probado lo siguiente:

*code = 'a'

No entiendo lo que pasa. A lo mejor es una tontería...

Espero que me puedan ayudar. Gracias

Vale, gracias

Hola, muy buenas. Primero quiero aclarar que estoy hablando de la API de Window. Hoy se me presenta una duda la cual es que por qué pasamos por referencia la estructura de una ventana en la función RegisterClassEx. Con esto, se me presenta otra duda: ¿puedo eliminar la estructura (habiendola inicializado con new) una vez llamada la función 'RegisterClasEx', o puede que el programa crashee al intentar acceder a la estructura que he eliminado? Es decir, la duda es que si Windows necesitará en un futuro la estrctura.

Era un ejemplo

Hola a tod@s. El problema proviene de función de la API de Windows en colaboración con OpenGL. La función es wglMakeCurrent(NULL, NULL). El problema es que que a veces (aleatoriamente) el programa crashea. He buscado por internet, pero nadie ha dado una respuesta que me sirva.

Esta función la utilizo cuando voy a cerrar el programa. Aquí está la función llamada al cerrarse el programa:

void Game::destroy() {
	wglMakeCurrent(NULL, NULL);
	wglDeleteContext(*hRC);
	ReleaseDC(*hWnd, *hDC);
 
	delete[] cWindow;
	delete[] hWnd;
	delete[] Msg;
	delete[] hDC;
	delete[] hRC;
}

Hola, muy buenas a tod@s, os comento:

Estaba creando un simple Hello World de OpenGL usando la API de Windows. He ido paso a paso, creando primero una ventana simple con la API de Windows (la cual se ha creado correctamente), y posteriormente he creado un contexto con el viejo OpenGL. El problema lo da la función SetPixelFormat, el cual da el código de error 3221684230 (en hexadecimal 0xC0070006). No tengo ni idea de que puede pasar, incluso he copiado/pegado un código de un contexto de OpenGL de Internet y me pasa lo mismo...

#ifndef UNICODE
#define UNICODE
#endif
 
#include <windows.h>
#include <gl\gl.h>
 
#include <chrono>
#include <thread>
 
#include <iostream>
 
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
 
int main() {
	WNDCLASSEX cWindow;
	HWND hWnd;
	MSG Msg;
	HDC hDC;
	HGLRC hRC;
 
	memset(&Msg, NULL, sizeof(MSG));
 
	cWindow.cbSize = sizeof(WNDCLASSEX);
	cWindow.hInstance = GetModuleHandle(NULL);
	cWindow.lpszClassName = L"¡Título!";
	cWindow.lpfnWndProc = WndProc;
	cWindow.lpszMenuName = NULL;
	cWindow.style = CS_OWNDC;
	cWindow.hIcon = LoadIcon(NULL, IDI_APPLICATION);
	cWindow.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
	cWindow.hCursor = LoadCursor(NULL, IDC_ARROW);
	cWindow.hbrBackground = (HBRUSH)3;
	cWindow.cbClsExtra = 0;
	cWindow.cbWndExtra = 0;
 
	if(RegisterClassEx(&cWindow) == NULL) {
		MessageBox(NULL, L"Error registring a window class!", L"Fatal error", MB_OK | MB_ICONERROR);
		PostQuitMessage(0);
	}
 
	hWnd = CreateWindowEx(0, L"¡Título!", L"¡Título!", WS_OVERLAPPEDWINDOW | WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT,
						  640, 480, HWND_DESKTOP, NULL, GetModuleHandle(NULL), (void *)NULL);
 
	if(hWnd = NULL) {
		MessageBox(NULL, L"Error creating a window!", L"Fatal error", MB_OK | MB_ICONERROR);
		PostQuitMessage(0);
	}
 
	ShowWindow(hWnd, SW_SHOWDEFAULT);
 
	PIXELFORMATDESCRIPTOR PFD;
	int choosenPFD;
 
	memset(&PFD, NULL, sizeof(PIXELFORMATDESCRIPTOR));
	PFD.nVersion = 1;
	PFD.nSize = sizeof(PIXELFORMATDESCRIPTOR);
	PFD.iPixelType = PFD_TYPE_RGBA;
	PFD.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
	PFD.cColorBits = 24;
	PFD.cDepthBits = 16;
	PFD.iLayerType = PFD_MAIN_PLANE;
 
	hDC = GetDC(hWnd);
 
	choosenPFD = ChoosePixelFormat(hDC, &PFD);
 
	if(!choosenPFD) {
		MessageBox(hWnd, L"Error choosing a pixel format (old)!", L"Fatal error", MB_OK | MB_ICONERROR);
		PostQuitMessage(0);
	}
 
	if(!SetPixelFormat(hDC, choosenPFD, &PFD)) {
		std::clog << GetLastError();
		MessageBox(hWnd, L"Error setting a pixel format (old)!", L"Fatal error", MB_OK | MB_ICONERROR);
		PostQuitMessage(0);
	}
 
	hRC = wglCreateContext(hDC);
 
	if(!hRC) {
		MessageBox(hWnd, L"Error creating a OpenGL context (old)!", L"Fatal error", MB_OK | MB_ICONERROR);
		PostQuitMessage(0);
	}
 
	if(!wglMakeCurrent(hDC, hRC)) {
		MessageBox(hWnd, L"Error linking a OpenGL context with a window!", L"Fatal error", MB_OK | MB_ICONERROR);
		PostQuitMessage(0);
	}
 
	while(Msg.message != WM_QUIT) {
		if(PeekMessage(&Msg, hWnd, NULL, NULL, PM_REMOVE)) {
			TranslateMessage(&Msg);
			DispatchMessage(&Msg);
		}
 
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
 
 
		SwapBuffers(hDC);
 
		std::this_thread::sleep_for(std::chrono::microseconds(11764));
	}
 
	wglMakeCurrent(NULL, NULL);
	wglDeleteContext(hRC);
	ReleaseDC(hWnd, hDC);
	DestroyWindow(hWnd);
	UnregisterClass(L"¡Título!", GetModuleHandle(NULL));
 
	return 0;
}
 
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
	switch(uMsg) {
		case WM_DESTROY:
			PostQuitMessage(0);
	}
 
	return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

C++ es un lenguaje que es secuencial a primera vista, es decir, que las cosas se van haciendo en el orden que vas escribiendo. En el caso de javascript, es cierto que tenemos la función 'setTimeout', pero C++ no usa ese método.

En C++, para que algo se repita indefinidamente (hasta que se cierra el juego, o así) tienes, como ya se ha mencionado, la recursividad.

Un ejemplo:

void run() {
    Act();
    Paint();
 
    run();
}

Analicemos:
Una vez se ejecuta por primera vez esa función 'run', se va a ejecutar Act(), posteriormente se va a ejecutar la función 'Paint' y por último se va a ejecutar la función 'run', y comencamos de nuevo el ciclo.

Si lo que quieres es pausar la función 'run' un tiempo determinado, harías lo siguiente:

#include <thread>
#include <chrono>
 
void run() {
    Act();
    Paint();
 
    std::this_thread::sleep_for(std::chrono::milliseconds(17));
    run();
}

Lo que hace 'std::this_thread::sleep_for(std::chrono::milliseconds(17));' es pausar el programa entero 17 milisegundos

Este es un ejemplo algo tosco, por lo que habría que añadirle mas cosas para que vaya mejor. Suerte