Monday, November 4, 2019

Память в си++.


Сначала был бит. И в конечном итоге в памяти мы храним данные: записываем, считываем, освобождаем, скорость с которой мы это делаем, допустимый объем, все это здорово. Но мы будем говорить не об этом, мы поговорим о том, как бы нам было удобнее хранить и использовать данные.
-
Первым делом нам нужны имена для наших значений, и еще нам нужно разбить данные на кусочки, получаем переменные и их типы. Пока не будем углубляться в то, что типы могут быть простыми, составными и пользовательскими. Но заострим внимание на том, что сами по себе имена переменных, это тоже данные которые нам нужно хранить. Тут нам на помощь приходят пространства имен, которые в свою очередь определяют время жизни переменной. Классический пример это фигурные скобки, в рамках которых не может быть переменных с одним именем и в тоже время наши переменные не могут быть доступны за их рамками. 
-
Не знаю кто придумал функции, но это круто, мы можем делить код на блоки, организовывая выполнение выражений в удобную для человека форму, путем передачи в них параметров и получения из них результата и все это посредством наших переменных. Передача и возврат по значению, по ссылке, по указателю, это тоже все круто, но мы чуть про другое. Для удобства, функции могут иметь вложенные функции, из одних функций могут вызываться другие функции, функции могут передаваться в качестве параметров и это порождает иерархию пространств имен и переменных, за которой человеку сложно уследить. А еще хотелось бы экономно использовать память, где все это должно храниться. Учитывая, что только человек знает, какие переменные ему нужны, оставим на его совести их создание, но может тогда хотя-бы помочь ему освобождать память. И тут нам на помощь приходит первый вид переменных:
-
Автоматические переменные. Переменные, которые автоматически удаляются, выходя за пределы пространства, в котором были объявлены. Заметим, что они все еще доступны во вложенных пространствах, но могут попасть в тень переменных с таким же именем. Частным случаем автоматических переменных, являются глобальные переменные. Это переменные, которые объявлены в глобальном пространстве имен и создаются при старте программы и освобождается при завершении. Поэтому первой точкой входа при старте программы является глобальное пространство имен, а затем уже функция main, которая запускается первой среди определенных в этом пространстве функций. Так как такие переменные активно порождаются и освобождаются, тем самым фрагментируя память, для эффективного хранения и управления используют структуру данных - стек. И выделяют отдельную область памяти, которая тоже называется стек.
-
Отлично, а как же нам тогда общаться между функциями? Частично эту проблему решают глобальные переменные, но это не всегда удобно, глобальное пространство имен делает видимой такую переменную для всех функций. Часто это бывает необходимо, когда нам нужны общие для всех константы, но что, если мы хотим ограничить доступ к переменной в рамках конкретного пространства имен. Например, чтобы созданная в рамках какой-то функции, переменная не освобождалась при выходе из функции, а сохраняла свое значение и была доступна при последующих запусках этой функции. В этом случае нам поможет второй вид переменных: Статические переменные. Такие переменные объявляются с помощью ключевого слова static. Их инициализация происходит при первом обращении к ним и значение хранится в специальной области памяти, которая называется статической. Пользовательские типы немного сложнее в работе со статической памятью, но это отдельная тема для разговора.
-
Говоря об использовании и управлении памятью нельзя не сказать про указатели. И это как раз тот инструмент, который позволяет эффективно управлять памятью вручную. Во-первых, оперировать значениями может быть очень ресурсоемко, например, пользовательский тип может в себе содержать целую иерархию простых и пользовательских типов, что займет значительный объем памяти и работа с ним может значительно нагрузить систему. Если привести аналогию из жизни, то проще носить между инстанциями документы на груз, чем таскать с собой грузовой контейнер. Таким “документом” на переменную является ее адрес в памяти. Но нам не хочется оперировать самими адресами, нужно что-то более подходящее. Для этого служат указатели(pointers), это переменные, которые хранят адреса переменных.
int x = 0;
int * pX = nullptr;
pX = &x;
int y = *pX;
-
Во-вторых, нам хотелось бы создавать и освобождать память, когда мы того сами захотим, без привязки к пространствам имен или времени жизни программы. Нужны данные - разместили (new), нет в них необходимости – удалили (delete), т.е. полный контроль. Для этих целей нам нужна отдельная область памяти и называется она куча(heap). Это место, где размещаются значения, на которые указывают указатели, в свою очередь сами указатели размещаются в стеке. Работа с указателями всегда считалась не простой, т.к. возлагает ответственность за освобождение памяти на человека (в отличии от автоматических переменных) и может привести к утечкам памяти. Облегчить ситуацию призваны так называемые “умные указатели”, а некоторые современные языки программирования (Java, C#) решают эту задачу с помощью “сборщиков мусора”. На что хотелось бы обратить внимание, при освобождении памяти, на которую указывает указатель, сам указатель также требуется обнулить (nullptr), рассмотрим на примере:

#include <iostream>

class Box{
public:
    Box();
    ~Box();
private:
    int bigData;
};

Box::Box() {
    std::cout << "Memory allocated!\n";
}

Box::~Box() {
    std::cout << "Memory deallocated!\n";
}

int main() {
    std::cout << "Pointer created!\n";
    Box * box = nullptr;
    std::cout << "address: " << box << std::endl;

    box = new Box();
    std::cout << "address: " << box << std::endl;

    delete box;
    std::cout << "address: " << box << std::endl;

    std::cout << "Pointer released!\n";
    box = nullptr;
    std::cout << "address: " << box << std::endl;

    return 0;
}
 
Output:
>>Pointer created!
>>address: 0
>>Memory allocated!
>>address: 0x26e00
>>Memory deallocated!
>>address: 0x26e00
>>Pointer released!
>>address: 0 

Перегуд В.

Thursday, October 31, 2019

Полиморфизм в си++.


Что такое полиморфизм? Давайте разбираться вместе. В каком-то смысле это свойство пользовательских типов. В более современных языках, таких как Java, в которых нет ограничений по обратной совместимости, полиморфизм “включен” по умолчанию. В нашем случае это не так, и его нужно включать принудительно. Но погодите, сам по себе полиморфизм не существует, сначала нам понадобится наследование. Вообще пользовательские типы это много всякой "дури", но не будем хвататься за все сразу. Наследовать свойства одних типов другими это удобно, преимущества такого подхода всем известны, это дает нам возможность строить родительские связи между типами и работать с наследниками как потомками одного родительского типа.

Давайте рассмотрим пример. Мы имеем родительский класс животные и его наследников кот и собака.
class Cat : public Animal {}; Cat cat;
Сложим наших наследников в контейнер и обработаем каждый элемент в цикле, например, вызовем унаследованный от родительского типа метод – подать сигнал. Создав контейнер, который содержит "элементы" родительского типа - животные и так как этому условию соответствуют наши наследники – кот и собака, помещаем их туда.
vector<Animal*> army = {&cat, &dog};
for(auto solder : army){ solder->signal(); }
 
Далее мы можем "решать проблему" тремя способами.
 
Первый способ – мы хотим сохранить нашу систему как можно более простой и принимаем как должное, что все животные могут “говорить”, просто издавать звуки, это достаточный для нас уровень абстракции, и мы не будем его дальше детализировать. Потому что на уровне наследников нам не важно, что именно они “говорят”, а более важно к примеру, что кот ловит мышей, а собака нарушителей границы, но при этом они могут подать звуковой сигнал. Создадим в родителе общий для всех наследников метод один раз и можем его использовать в любом наследнике, которых может быть любое количество.
class Animal{ void signal() { todo(); } }; 
 
Второй способ, когда у нас возникла необходимость конкретизировать поведение некоторых наследников. По каким-то причинам это может понадобится - переопределить поведение наследника, чтобы оно отличалось от родительского.
class Cat : public Animal{ void signal() { todo(); } };
Но в отличии от Java, только этого недостаточно. Мы должны указать в родительском типе, что при наличии преопределенного метода в наследнике, нужно использовать именно его, с помощью ключевого слова virtual:
virtual void signal() { todo(); }
В добавок для удобства можно использовать ключевое слово override в наследнике:
void signal() override { todo(); }
 
Третий способ, это частный случай второго способа, когда у нас возникла необходимость конкретизировать поведение всех наследников. В этом случае, с одной стороны нам не нужно определять общий для вех наследников метод - мы это сделаем в самих наследниках, с другой стороны нам нужно как-то указать на необходимость обязательного определения такого поведения в наследниках, т.к. если мы его не определим в родителе или наследнике, то при его вызове получим ошибку. В этом случае нам поможет чисто виртуальный метод, записанный в родительском типе в таком виде:
virtual void signal() = 0;
 
“И где тут полиморфизм?”, спросите вы. И вообще зачем он? Для меня ответ такой – это инструмент, который позволяет решать задачу действуя от общего к частному, что часто очень полезно. При таком подходе мы можем создать скелет сложной системы и потом изменять ее, путем добавления или замены ее элементов, которые будут вести себя по разному, настоящая магия и превращения (morph). В нашем случае мы работаем с животными, которые могут быть и вести себя как кот, собака и т.д. Давайте рассмотрим сам механизм:
Animal* x = &cat;
x->signal();
Слева у нас родительский тип животное, справа наследник кот. И у родителя, и у наследника есть поведение - сигнал, какой его вариант будет использован при вызове, родительский или потомка?
 
Если мы хотим, чтобы использовался родительский, это обычное наследование без полиморфизма, это рассмотренный выше первый способ. Если мы хотим использовать вариант потомка, что в свою очередь дает возможность использовать собственные варианты для разных потомков, то есть вести себя по-разному – полиморфно. То определяем родительское поведение, как виртуальное, это рассмотренный выше второй способ.
 
Код, который можно скомпилировать:
#include <iostream>
#include <vector>

class Animal {
public:
    virtual void signal() {
        std::cout << "Animal!\n";
    }
};

class Cat : public Animal {
public:
    void signal() override {
        std::cout << "Cat!\n";
    }
};

class Dog : public Animal {
public:
    //void signal() override {
    //    std::cout << "Dog!\n";
    //}
};

int main() {
    Cat cat;
    Dog dog;
    std::vector<Animal *> army = {&cat, &dog};
    for (auto solder:army) {
        solder->signal();
    }

    return 0;
}

Output:
>>Cat!
>>Animal!

P.S. Статья писалась с целью навести порядок в голове, буду рад если еще кому-то будет полезно.
Перегуд В.

Friday, October 4, 2019

Priority Queue


#include <string>
#include <map>
#include <iostream>

template <typename T>
class FakePriorityQueue
{
public:
    FakePriorityQueue()
    {
        m_list = new std::map<T, float>();
    }

    ~FakePriorityQueue()
    {
        m_list->clear();
        delete m_list;
    }

    bool Empty()
    {
        return m_list->empty();
    }

    void Enqueue(T element, float priority)
    {
        m_list->insert(std::pair<T, float>{element, priority});
    }

    T Dequeue()
    {
        if (m_list->empty())
        {
            //throw
        }
        T best = (T)m_list->begin()->first;
        float priority = m_list->at(best);

        for (auto &[candidate, val] : *m_list)
        {

            if (m_list->at(candidate) < priority)
            {
                best = candidate;
                priority = m_list->at(candidate);
            }
        }

        m_list->erase(best);
        return best;
    }

private:
    std::map<T, float> *m_list = nullptr;
};

int main()
{
    auto myXXX = FakePriorityQueue<std::string>();

    myXXX.Enqueue("B", 20.0f);
    myXXX.Enqueue("C", 30.0f);
    myXXX.Enqueue("A", 10.0f);

    while (!myXXX.Empty())
    {
        std::cout << myXXX.Dequeue() << std::endl;
    }
    std::cout << "Empty!" << std::endl;
}

////////////////////////
> .\game.exe
A
B
C
Empty!



=================================
            extract keys from a C++ map
=================================
-----------
std::vector<std::string> extract_keys(std::map<std::string, std::string> const& input_map) {
  std::vector<std::string> retval;
  for (auto const& element : input_map) {
    retval.push_back(element.first);
  }
  return retval;
}
----------
std::vector<std::string> extract_values(std::map<std::string, std::string> const& input_map) {
  std::vector<std::string> retval;
  for (auto const& element : input_map) {
    retval.push_back(element.second);
  }
  return retval;
}
----------
template<typename TK, typename TV>
std::vector<TK> extract_keys(std::map<TK, TV> const& input_map) {
  std::vector<TK> retval;
  for (auto const& element : input_map) {
    retval.push_back(element.first);
  }
  return retval;
}
----------
template<typename TK, typename TV>
std::vector<TV> extract_values(std::map<TK, TV> const& input_map) {
  std::vector<TV> retval;
  for (auto const& element : input_map) {
    retval.push_back(element.second);
  }
  return retval;
}

----------
#include <iostream>
#include <unordered_map>

template<typename K, typename V>
void print_map(std::unordered_map<K,V> const &m)
{
    for (auto const& pair: m) {
        std::cout << "{" << pair.first << ": " << pair.second << "}\n";
    }
}

int main()
{
    std::unordered_map<int, char> m =
    {
        {1, 'A'},
        {2, 'B'},
        {3, 'C'}
    };
    print_map(m);
    return 0;
}

Thursday, September 19, 2019

Clion + SDL2 (MSYS2)

cmake_minimum_required(VERSION 3.15)
project(untitled5)

set(CMAKE_CXX_STANDARD 17)
set(EXECUTABLE_NAME "game")

set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -mwindows")

file(GLOB source ${CMAKE_SOURCE_DIR}/src/*.cpp)

add_executable(${EXECUTABLE_NAME} ${source})

target_link_libraries(${EXECUTABLE_NAME}
        lua
        libz
        tinyxml
        libsfml-audio
        libsfml-graphics
        libsfml-network
        libsfml-system
        libsfml-window
        mingw32
        SDL2main
        SDL2
        SDL2_image
        SDL2_ttf
        SDL2_mixer
        Qt5Core
        Qt5Gui
        Qt5Widgets)


=====================================================================
#include <SDL2/SDL.h>

SDL_Window *g_pWindow = nullptr;
SDL_Renderer *g_pRenderer = nullptr;


int main(int argc, char *argv[]) {
    // initialize SDL
    if (SDL_Init(SDL_INIT_EVERYTHING) >= 0) {
        // create window
        g_pWindow = SDL_CreateWindow("Game",
                                     SDL_WINDOWPOS_CENTERED,
                                     SDL_WINDOWPOS_CENTERED,
                                     640,
                                     480,
                                     SDL_WINDOW_SHOWN);
        if (g_pWindow != nullptr) {
            // create renderer
            g_pRenderer = SDL_CreateRenderer(g_pWindow, -1, 0);
        } else {
            // sdl not initialized
            return 1;
        }
    }
    // sdl is initialized
    // set to black
    SDL_SetRenderDrawColor(g_pRenderer, 0, 0, 0, 255);
    // clear window to black
    SDL_RenderClear(g_pRenderer);
    // show window
    SDL_RenderPresent(g_pRenderer);
    // set a delay
    SDL_Delay(5000);
    //
    // clean up SDL an quit
    SDL_DestroyRenderer(g_pRenderer);
    SDL_DestroyWindow(g_pWindow);
    SDL_Quit();

    return 0;
}

Sunday, July 7, 2019

VS Code + SDL2 + SFML + Qt5

------------MSYS2-------------
//https://www.msys2.org
//update
pacman -Syu
pacman -Su

//C++
pacman -S mingw-w64-x86_64-clang
pacman -S mingw-w64-x86_64-lldb
pacman -S mingw-w64-x86_64-lld
pacman -S mingw-w64-x86_64-clang-tools-extra
pacman -S mingw-w64-x86_64-libc++

====================================== 
pacman -S mingw-w64-x86_64-gcc
pacman -S mingw-w64-x86_64-gdb
pacman -S mingw-w64-x86_64-boost
pacman -S mingw-w64-x86_64-ninja 

//https://www.libsdl.org
pacman -S mingw-w64-x86_64-SDL2

pacman -S mingw-w64-x86_64-SDL2_gfx
pacman -S mingw-w64-x86_64-SDL2_image 
pacman -S mingw-w64-x86_64-SDL2_mixer
pacman -S mingw-w64-x86_64-SDL2_net
pacman -S mingw-w64-x86_64-SDL2_ttf
 
//https://www.sfml-dev.org
pacman -S mingw-w64-x86_64-sfml  
 
//https://www.qt.io
pacman -S mingw-w64-x86_64-qt5
pacman -S mingw-w64-x86_64-vulkan
//https://www.gtk.org
pacman -S mingw-w64-x86_64-gtk3
pacman -S mingw-w64-x86_64-glade
pacman -S mingw-w64-x86_64-devhelp  
 

//https://www.sqlite.org
pacman -S mingw-w64-x86_64-sqlite3  
pacman -S mingw-w64-x86_64-tinyxml
pacman -S mingw-w64-x86_64-tinyxml2 
pacman -S mingw-w64-x86_64-zlib
pacman -S mingw-w64-x86_64-nlohmann_json 
pacman -S mingw-w64-x86_64-rapidjson 
 
and more:
vim 
lua
glm
git
make
-cmake 
 
---------SYSTEM_PATHES-------- 
 
PATH
C:\msys64\mingw64\bin 
 
C_INCLUDEDE_PATH
C:\msys64\mingw64\include\
 
CPLUS_INCLUDE_PATH
C:\msys64\mingw64\include\;
C:\msys64\mingw64\include\c++\9.1.0 
 
LIBRARY_PATH
C:\msys64\mingw64\lib     

==========SDL2===========
-----------a.cpp-------------

#include <SDL2\SDL.h>

int main(int argc, char *argv[])
{
    // Start SDL2
    SDL_Init(SDL_INIT_EVERYTHING);

    // Create a Window in the middle of the screen
    SDL_Window *window = 0;

    window = SDL_CreateWindow("game!",
                              SDL_WINDOWPOS_CENTERED,
                              SDL_WINDOWPOS_CENTERED,
                              640, 480,
                              SDL_WINDOW_SHOWN);

    // Delay so that we can see the window appear
    SDL_Delay(2000);

    // Cleanup and Quit
    SDL_DestroyWindow(window);
    SDL_Quit();

    return 0;
} 


---------cli----------

g++ a.cpp -lmingw32 -mwindows -lSDL2main -lSDL2 -o a.exe
 
----------Makefile----------- 

build:
 g++ -w -std=c++14 -Wfatal-errors \
 ./src/*.cpp \
 -o game \
 -I"./include" \
 -L"./lib" \
 -lmingw32 \
 -mwindows \
 -llua \
 -lSDL2main \
 -lSDL2 \
 -lSDL2_image \
 -lSDL2_ttf \
 -lSDL2_mixer;

clean:
 rm ./game;

run:
 ./game;

--------make--------

./make
./make run
./make clean


===============VSCode================
=====================================

------------task.json----------------

{
    // See https://go.microsoft.com/fwlink/?LinkId=733558
    // for the documentation about the tasks.json format
    "version": "2.0.0",
    "tasks": [
        {
            "type": "shell",
            "label": "g++ build main.cpp",
            "command": "g++",
            "args": [
                //warnings
                "-Wall",
                //debug config
                "-g",
                //cpp standard
                "-std=c++14",
                //source files
                "./src/*.cpp",
                //Directories
                "-IC:/msys64/mingw64/include; C:/msys64/mingw64/include/c++/9.1.0",
                "-LC:/msys64/mingw64/lib",
                "-lmingw32",
                "-mwindows",

                "-llua",
                //SDL2
                "-lSDL2main",
                "-lSDL2",
                "-lSDL2_image",
                "-lSDL2_ttf",
                "-lSDL2_mixer",

                //SFML
                "-lsfml-audio",
                "-lsfml-graphics",
                "-lsfml-network",
                "-lsfml-system",
                "-lsfml-window",

                //Qt5
                "-lQt5Core",
                "-lQt5Gui",
                "-lQt5Widgets",
                //output name
                "-o",
                "game.exe"
            ],
            "options": {
                "cwd": "${workspaceFolder}"
            },
            "problemMatcher": [
                "$gcc"
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            }
        }
    ]
}



---------------launch.json-----------------------

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "(gdb) Launch",
            "type": "cppdbg",
            "request": "launch",
            "program": "${workspaceFolder}/game.exe",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "miDebuggerPath": "C:/msys64/mingw64/bin/gdb.exe",
            "setupCommands": [
                {
                    "description": "Enable pretty-printing for gdb",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ]
        }
    ]
}



-------------------c_cpp_properties.json---------------------

{
    "configurations": [
        {
            "name": "Win32",
            "includePath": [
                "${workspaceFolder}/**",
                "C:/msys64/mingw64/include",
                "C:/msys64/mingw64/include/c++/9.1.0"
            ],
            "defines": [
                "_DEBUG",
                "UNICODE",
                "_UNICODE"
            ],
            "windowsSdkVersion": "10.0.17763.0",
            "compilerPath": "C:/msys64/mingw64/bin/g++.exe",
            "cStandard": "c11",
            "cppStandard": "c++17",
            "intelliSenseMode": "gcc-x64",
            "browse": {
                "path": [
                    "${workspaceFolder}",
                    "C:/msys64/mingw64/include",
                    "C:/msys64/mingw64/include/c++/9.1.0"
                ],
                "limitSymbolsToIncludedHeaders": true,
                "databaseFilename": ""
            }
        }
    ],
    "version": 4
}


--------------------settings.json-------------------------

{
    "editor.formatOnSave": true,
    "editor.suggestSelection": "first",
    "workbench.colorTheme": "One Dark Pro",
    "breadcrumbs.enabled": true,
    "debug.allowBreakpointsEverywhere": true,
    "editor.renderWhitespace": "all"
}



============Qt5======================
-------------------main.cpp---------------------------------

#include <QtWidgets/QApplication>
#include <QtWidgets/QLabel>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QGridLayout>

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    //Label
    QLabel *label = new QLabel("Hello world !");
    label->setStyleSheet("QLabel:hover { color: rgb(255, 0, 0)}");
    label->setFont(QFont("Comic Sans MS", 18));
    //Button
    QPushButton *myButton = new QPushButton(QIcon("./assets/filesaveas.png"), "Push Me");
    myButton->setToolTip("Click this to turn back the hands of time");
    //Layout
    QGridLayout *layout = new QGridLayout;
    layout->addWidget(label, 0, 0);
    layout->addWidget(myButton, 0, 1);
    //Window
    QWidget *window = new QWidget;
    window->setLayout(layout);
    window->show();

    return app.exec();
}



=============SFML==================
---------------------main.cpp-----------------------------
#include <SFML/Graphics.hpp>

int main()
{
    sf::RenderWindow window(sf::VideoMode(640, 480), "SFML Application");
    sf::CircleShape shape;
    shape.setRadius(40.f);
    shape.setPosition(100.f, 100.f);
    shape.setFillColor(sf::Color::Cyan);
    while (window.isOpen())
    {
        sf::Event event;
        while (window.pollEvent(event))
        {
            if (event.type == sf::Event::Closed)
                window.close();

        }
         window.clear();
         window.draw(shape);
         window.display();
    }
}










MSYS2 + SDL2

1.Download and install msys2 64bit

2.Update msys2

  • Update msys2 64bit after install by running pacman -Syu if pacman needs to be updated you might have to close and reopen the terminal and run pacman -Syu again

3.Install build tools

  • pacman -S git mingw-w64-x86_64-toolchain mingw64/mingw-w64-x86_64-SDL2 mingw64/mingw-w64-x86_64-SDL2_mixer mingw64/mingw-w64-x86_64-SDL2_image mingw64/mingw-w64-x86_64-SDL2_ttf mingw64/mingw-w64-x86_64-SDL2_net mingw64/mingw-w64-x86_64-cmake make

4.Compile Hello World

hello.c

#include <stdio.h>
#include <SDL2/SDL.h>

const int WIDTH = 800, HEIGHT = 600;

int main(int argc, char *argv[]) {
  SDL_Window *window;
  SDL_Renderer *renderer;
  if(SDL_Init(SDL_INIT_EVERYTHING) < 0) {
    printf("SDL_Init failed: %s\n", SDL_GetError());
    return 1;
  }

  window = SDL_CreateWindow("Hello, World!",
                                        SDL_WINDOWPOS_UNDEFINED,
                                        SDL_WINDOWPOS_UNDEFINED,
                                        WIDTH, HEIGHT,
                                        SDL_WINDOW_ALLOW_HIGHDPI);
  if(window == NULL) {
    printf("Could not create window: %s\n", SDL_GetError());
    return 1;
  }
  
  renderer = SDL_CreateRenderer(window, -1, 0);
  SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
  SDL_RenderClear(renderer);

  SDL_RenderPresent(renderer);
  
  SDL_Event event;
  while(1) {
    if(SDL_PollEvent(&event)) {
      if(event.type == SDL_QUIT) {
        break;
      }
    }
  }

  SDL_DestroyWindow(window);

  SDL_Quit();
  return 0;
}

Compiling with mingw64

gcc -o hello -Wall hello.c `sdl2-config --cflags --libs`