получить юникод

#ifndef __STDC_ISO_10646__
#error "wchar_t wide characters have to be Unicode code points"
#endif

char c[] = { 0xd0, 0xb0 };
printf ( "%s\n", c );

#include <stdio.h>
#include <stdint.h>
#include <wchar.h>
#include <locale.h>

#ifndef __STDC_ISO_10646__
#error "wchar_t wide characters have to be Unicode code points"
#endif


union utf8
{
    wchar_t code;
    uint8_t bytes[sizeof (wchar_t)];
};

typedef union utf8 utf8;

int main(void)
{
    setlocale(LC_ALL, "");
    utf8 c = {0};
    c.code = getwchar();
    for (size_t i = 0; i < sizeof (wchar_t); ++i)
    {
        wprintf(L"byte[%zu]: 0x%.02hhX\n", i, c.bytes[i]);
    }
    
}

./a.out 
а
byte[0]: 0x30
byte[1]: 0x04
byte[2]: 0x00
byte[3]: 0x00

char c[] = { 0xd0, 0xb0 };

#include <stdio.h>

int main(void)
{
    printf("%s\n", u8"\u0430");
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    char str[] = u8"\u0430";
    size_t len = strlen(str);
    for (size_t i = 0; i < len; ++i)
    {
        printf("str[%zu]: 0x%.02hhX\n", i, str[i]);
    }

    char buffer[512] = {0};
    scanf("%511s", buffer);
    printf("buffer = %s\n", buffer);

    len = strlen(buffer);
    for (size_t i = 0; i < len; ++i)
    {
        printf("buffer[%zu]: 0x%.02hhX\n", i, buffer[i]);
    }    
}

./a.out str[0]: 0xD0
str[1]: 0xB0
а
buffer = а
buffer[0]: 0xD0
buffer[1]: 0xB0

./a.out 
H
e
l
l
o
,
 
日
本
語
と
 
М
и
р
!

#include <string>
#include <iostream>
#include <cinttypes>
#include <ciso646>
#include <cassert>

using namespace std;

static string get_utf8_character(const char* str)
{
    assert (str != nullptr);

    size_t len{0};
    uint8_t byte{static_cast<uint8_t>(*str)};
    if (byte < 128) {
        len = 1;
    } else if (byte < 224) {
        len = 2;
    } else if (byte < 240) {
        len = 3;
    } else if (byte < 248) {
        len = 4;
    } else if (byte < 252) {
        len = 5;
    } else {
        len = 6;
    }
    return string(str, str + len);
}

class utf8string_iterator
{
    const char* s {nullptr};
public:
    explicit utf8string_iterator (const char* str)
        : s{str}
    {}
    string operator*() const
    {
        return get_utf8_character(s);
    }
    utf8string_iterator& operator++()
    {
        auto temp (get_utf8_character (s));
        s += temp.size();
        return *this;
    }
    bool operator!= (const utf8string_iterator) const
    {
        return (s != nullptr) and (*s != '\0');
    }
};


class utf8string_range
{
    const char* s {nullptr};
public:
    explicit utf8string_range (const char* str)
        : s{str}
    {}
    utf8string_iterator begin() const
    {
        return utf8string_iterator{s};
    }
    utf8string_iterator end() const
    {
        return utf8string_iterator{nullptr};
    }
};

int main()
{
    for (auto ut8_chars : utf8string_range("Hello, 日本語と Мир!"))
    {
        cout << ut8_chars << endl;
    }
}

#include <assert.h>
#include <stdlib.h>
#include <inttypes.h>
#include <stdio.h>
#include <string.h>

#ifndef __cplusplus
#define nullptr ((void*)+0)
#endif

#ifndef __cplusplus
#ifndef thread_local
#define thread_local _Thread_local
#endif
#endif

static const char* get_utf8_character(const char* str)
{
    assert (str != nullptr);

    thread_local static char buffer[7] = {0};

    size_t len = 0;
    uint8_t byte = (uint8_t)(*str);

    if (byte < 128) {
        len = 1;
    } else if (byte < 224) {
        len = 2;
    } else if (byte < 240) {
        len = 3;
    } else if (byte < 248) {
        len = 4;
    } else if (byte < 252) {
        len = 5;
    } else {
        len = 6;
    }

    memcpy(buffer, str, len);
    buffer[len] = '\0';
    return buffer;
}

int main(void)
{
    
    for (const char *s = "Hello, 日本語と Мир!", *utf8_chars = get_utf8_character(s);
         *s != '\0';
         s+= strlen(utf8_chars), utf8_chars = get_utf8_character(s))
    {
        printf("%s\n",  utf8_chars);
    }
}

>>> chr(0xd0b0)
'킰'
>>> chr(0x0430)
'а'

int utfprocesschar(int in)
{
	static int m = -1, k = 0; //multibyte state
	static int uc = 0; //unicode char
	
	if( !in )
	{
		m = -1;
		k = 0;
		uc = 0;
		return 0;
	}

	// Get character length
	if(m == -1)
	{
		uc = 0;
		if( in >= 0xF8 )
			return 0;
		else if( in >= 0xF0 )
			uc = in & 0x07, m = 3;
		else if( in >= 0xE0 )
			uc = in & 0x0F, m = 2;
		else if( in >= 0xC0 )
			uc = in & 0x1F, m = 1;
		else if( in <= 0x7F)
			return in; //ascii
		// return 0 if we need more chars to decode one
		k=0;
		return 0;
	}
	// get more chars
	else if( k <= m )
	{
		uc <<= 6;
		uc += in & 0x3F;
		k++;
	}
	if( in > 0xBF || m < 0 )
	{
		m = -1;
		return 0;
	}
	if( k == m )
	{
		k = m = -1;
		return in;
	}
	return 0;
}

auto ut8_chars : 

const auto& ut8_chars :