VkWin32SurfaceCreateInfoKHR not working

#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>
#include <iostream>
#include <vector>
#include <map>

class app {
public:
    void run() {
        loading();
        running();
        closing();
    }
private:
    GLFWwindow* window;
    VkInstance instance;
    VkDevice device;
    VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
    VkQueue graphicsQueue;
    VkSurfaceKHR surface;

    void loading() {
        glfwInit();
        glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
        glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
        window = glfwCreateWindow(640, 360, "Vulkan", nullptr, nullptr);

        uint32_t count;
        VkInstanceCreateInfo createInfo{};

        createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
        createInfo.ppEnabledExtensionNames = glfwGetRequiredInstanceExtensions(&count);
        createInfo.enabledExtensionCount = count;
        createInfo.enabledLayerCount = 0;
        if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) {
            throw std::runtime_error("Failed to initiate Vulkan Instance");
        }

        vkEnumeratePhysicalDevices(instance, &count, nullptr);
        if (count == 0) {
            throw std::runtime_error("No supported graphics card found");
        }
        std::vector<VkPhysicalDevice> devices(count);
        vkEnumeratePhysicalDevices(instance, &count, devices.data());
        std::multimap<uint32_t, VkPhysicalDevice> candidates;
        for (const VkPhysicalDevice& device : devices) {

            VkPhysicalDeviceProperties prop;
            VkPhysicalDeviceFeatures feature;
            vkGetPhysicalDeviceProperties(device, &prop);
            vkGetPhysicalDeviceFeatures(device, &feature);
            uint32_t score = 0;

            switch (prop.deviceType) {
            case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
                score += 3;
                break;
            case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU || VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
                score += 2;
                break;
            default:
                score += 1;
                break;
            }
            candidates.insert(std::make_pair(score, device));
        }
        physicalDevice = candidates.rbegin()->second;

        vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &count, nullptr);
        std::vector<VkQueueFamilyProperties> families(count);
        vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &count, families.data());
        std::map <int, int> QueueFamilies;
        int i = 0;
        for (const VkQueueFamilyProperties& family : families) {
            QueueFamilies[i] = 0;
            if (family.queueFlags & VK_QUEUE_GRAPHICS_BIT) {
                QueueFamilies[i] = QueueFamilies[i] | VK_QUEUE_GRAPHICS_BIT;
            }
            if (family.queueFlags & VK_QUEUE_COMPUTE_BIT) {
                QueueFamilies[i] = QueueFamilies[i] | VK_QUEUE_COMPUTE_BIT;
            }
            if (family.queueFlags & VK_QUEUE_TRANSFER_BIT) {
                QueueFamilies[i] = QueueFamilies[i] | VK_QUEUE_TRANSFER_BIT;
            }
            if (family.queueFlags & VK_QUEUE_SPARSE_BINDING_BIT) {
                QueueFamilies[i] = QueueFamilies[i] | VK_QUEUE_SPARSE_BINDING_BIT;
            }
            if (family.queueFlags & VK_QUEUE_PROTECTED_BIT) {
                QueueFamilies[i] = QueueFamilies[i] | VK_QUEUE_PROTECTED_BIT;
            }
            i++;
        }

        VkDeviceQueueCreateInfo queueInfo{};
        queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
        queueInfo.queueFamilyIndex = 0;
        queueInfo.queueCount = 1;
        float queuePriority = 1.0f;
        queueInfo.pQueuePriorities = &queuePriority;
        VkPhysicalDeviceFeatures deviceFeatures{};
        VkDeviceCreateInfo dcreateInfo{};
        dcreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
        dcreateInfo.pQueueCreateInfos = &queueInfo;
        dcreateInfo.queueCreateInfoCount = 1;
        dcreateInfo.pEnabledFeatures = &deviceFeatures;
        createInfo.ppEnabledLayerNames = {};
        vkCreateDevice(physicalDevice, &dcreateInfo, nullptr, &device);
        vkGetDeviceQueue(device, 0, 0, &graphicsQueue);

        VkWin32SurfaceCreateInfoKHR createInfo{};
    }
    void running() {
        while (!glfwWindowShouldClose(window)) {
            glfwPollEvents();
        }
    }
    void closing() {
        vkDestroyDevice(device, nullptr);
        vkDestroyInstance(instance, nullptr);
        glfwDestroyWindow(window);
        glfwTerminate();
    }
};

int main() {
    app a;
    try
    {
        a.run();
    }
    catch (const std::exception& e)
    {
        std::cerr << e.what() << std::endl;
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}