Vulkan API — (vkEnumeratePhysicalDevices() == VK_ERROR_INITIALIZATION_FAILED) = true

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <vulkan/vulkan.h>

int main () {
    VkInstance instance;
    VkInstanceCreateInfo instanceCreateInfo;
    VkApplicationInfo    appInfo;

    memset (&instanceCreateInfo, 0, sizeof (instanceCreateInfo));
    memset (&appInfo, 0, sizeof (appInfo));

    appInfo.applicationVersion = VK_MAKE_VERSION (1, 0, 0);
    appInfo.apiVersion         = VK_MAKE_VERSION (1, 0, 0);
    appInfo.engineVersion      = VK_MAKE_VERSION (1, 0, 0);
	nfo.pApplicationName   =	
    appInfo.pEngineName        = "No engine";
    appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;

    instanceCreateInfo.pApplicationInfo = &appInfo;
    instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;

    VkResult res = vkCreateInstance (&instanceCreateInfo, NULL, &instance);
    if (res != VK_SUCCESS) {
        exit (1);
    }

	32_t count = 0;
    vkEnumeratePhysicalDevices (instance, &count, NULL);
    if (count == 0) {
        exit (1);
    }

    VkPhysicalDevice dev;
    count = 1;
    vkEnumeratePhysicalDevices (instance, &count, &dev);

	ysicalDeviceProperties deviceProperties;
    vkGetPhysicalDeviceProperties(dev, &deviceProperties);

    printf ("%s\n", deviceProperties.deviceName);

    return 0;
}

khronos_validation.enables=VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT
khronos_validation.report_flags=error,warn,perf,info

#include <iostream>
#include <cstdint>
#include <cstdlib>
#include <vulkan/vulkan.h>
#include <vector>
#include <vulkan/vulkan_core.h>
#include <string_view>
#include <xcb/xcb.h>
#include <vulkan/vulkan_xcb.h>
#include <stdexcept>

namespace core::vk {

class Instance final {
    VkInstance                        instance;
    static constexpr std::string_view appName { "vulkan_xcb" };
    static constexpr std::string_view engineName { "vulkan_xcb" };
    static constexpr uint32_t         appVersion { 1 };
    static constexpr uint32_t         engineVersion { 1 };
    static constexpr uint32_t         apiVersion { VK_MAKE_VERSION(
    1, 0, 3 ) };
    std::vector< const char * >       extensions {
        { VK_KHR_SURFACE_EXTENSION_NAME,
          VK_KHR_XCB_SURFACE_EXTENSION_NAME }
    };
    VkInstanceCreateInfo instanceCreateInfo {};
    VkApplicationInfo    appInfo {};

public:
    Instance() {
        appInfo.applicationVersion = appVersion;
        appInfo.apiVersion         = apiVersion;
        appInfo.engineVersion      = engineVersion;
        appInfo.pApplicationName   = appName.data();
        appInfo.pEngineName        = engineName.data();
        appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
        appInfo.pNext = nullptr;

        instanceCreateInfo.pApplicationInfo = &appInfo;
        instanceCreateInfo.sType =
        VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
        instanceCreateInfo.pNext = nullptr;
        instanceCreateInfo.flags = 0;

        instanceCreateInfo.enabledExtensionCount = extensions.size();
        instanceCreateInfo.ppEnabledExtensionNames =
        extensions.data();

        auto result =
        vkCreateInstance( &instanceCreateInfo, nullptr, &instance );
        switch ( result ) {
        case VK_SUCCESS: break;
        case VK_ERROR_INCOMPATIBLE_DRIVER:
            throw std::runtime_error(
            "VK_ERROR_INCOMPATIBLE_DRIVER" );
            break;
        default:
            throw std::runtime_error( "Unknow error in VkInstance" );
        }
    }
    ~Instance() { vkDestroyInstance( instance, nullptr ); std::cout << "RR" << std::endl; }

    VkInstance get() const { return instance; }
};

class Devices final {
    struct PhysicalDevices final {
        std::uint32_t                   count;
        std::vector< VkPhysicalDevice > devices;

        PhysicalDevices( Instance &instance ) :
        count { [ &instance ]() -> std::uint32_t {
            std::uint32_t count { 0 };
            vkEnumeratePhysicalDevices(
            instance.get(), &count, nullptr );
            return count;
        }() },
        devices { count } {
            VkResult result = vkEnumeratePhysicalDevices(
            instance.get(),
            &count,
            const_cast< VkPhysicalDevice * >( devices.data() ) );
            std::cout << "Detected devices: " << devices.size()
                      << std::endl;

            switch ( result ) {
            case VK_SUCCESS: break;
            case VK_ERROR_OUT_OF_DEVICE_MEMORY:
                throw std::runtime_error {
                    "In Devices::PhysicalDevices() vkEnumeratePhysicalDevices returned VK_ERROR_OUT_OF_DEVICE_MEMORY"
                };
            case VK_ERROR_INITIALIZATION_FAILED:
                throw std::runtime_error {
                    "In Devices::PhysicalDevices() vkEnumeratePhysicalDevices returned VK_ERROR_INITIALIZATION_FAILED"
                };
            case VK_ERROR_OUT_OF_HOST_MEMORY:
                throw std::runtime_error {
                    "In Devices::PhysicalDevices() vkEnumeratePhysicalDevices returned VK_ERROR_OUT_OF_HOST_MEMORY"
                };
            default:
                std::cout << count << std::endl;
                throw std::runtime_error {
                    "In Devices::PhysicalDevices() vkEnumeratePhysicalDevices returned failure"
                };
            }
        }
        ~PhysicalDevices() {}
    };

    struct LogicalDevices final {};

    Instance        &instance;
    PhysicalDevices physDevices;

public:
    Devices( Instance &instance ) :
    instance { instance }, physDevices( instance ) {}

    void printDevicesInfo() const {
        VkPhysicalDeviceProperties phDevProp;
        for ( auto && device : physDevices.devices ) {
            vkGetPhysicalDeviceProperties( device, &phDevProp );
            std::cout << phDevProp.deviceName << std::endl;
        }
    }
};

}   // namespace core::vk

int main() {
    core::vk::Instance vkInstance {};

    core::vk::Devices devices { vkInstance };
    devices.printDevicesInfo();

    return EXIT_SUCCESS;
}

operator VkInstance()

    Instance        instance; // <---------- копируется сюда
    PhysicalDevices physDevices;

public:
    Devices( Instance instance ) :
    instance { instance }, physDevices( instance ) {} // <--------- копирование происходит здесь

        PhysicalDevices( Instance instance ) :
        count { [ instance ]() -> std::uint32_t {
            std::uint32_t count { 0 };
            vkEnumeratePhysicalDevices(
            instance.get(), &count, nullptr );
            return count;
        }() },

Instanse instanse();

#include <iostream>
#include <vector>

int main(void) {
  std::vector<int> v1{99};
  std::vector<int> v2(99);

  std::cout << "v1, " << v1.size() << std::endl;
  std::cout << "v2, " << v2.size() << std::endl;
  return 0;
}

v1, 1
v2, 99

#include <iostream>
#include <string>
#include <vector>

// не знаю, как на самом деле, но написано opaque, скорее указатель на incomplete struct, но даже это работает "как ожидается"
using VkPhysicalDevice = void *;

int
main(void)
{
    std::vector<VkPhysicalDevice> v1(10);
    std::vector<VkPhysicalDevice> v2{10};

    std::cout << v1.size() << std::endl;
    std::cout << v2.size() << std::endl;

    return 0;
}

10
10