Generic strlen

#include <stddef.h>
#include <stdint.h>
#include <immintrin.h>

template <typename uintX_t>
inline __m256i _mm256_cmpeq_epiX(__m256i a, __m256i b);
template <>
inline __m256i _mm256_cmpeq_epiX<uint8_t>(__m256i a, __m256i b) {
    return _mm256_cmpeq_epi8(a, b);
}
template <>
inline __m256i _mm256_cmpeq_epiX<uint16_t>(__m256i a, __m256i b) {
    return _mm256_cmpeq_epi16(a, b);
}
template <>
inline __m256i _mm256_cmpeq_epiX<uint32_t>(__m256i a, __m256i b) {
    return _mm256_cmpeq_epi32(a, b);
}
template <>
inline __m256i _mm256_cmpeq_epiX<uint64_t>(__m256i a, __m256i b) {
    return _mm256_cmpeq_epi64(a, b);
}

template <typename uintX_t>
inline __m256i _mm256_set1_epiX(uintX_t value);
template <>
inline __m256i _mm256_set1_epiX<uint8_t>(uint8_t value) {
    return _mm256_set1_epi8(value);
}
template <>
inline __m256i _mm256_set1_epiX<uint16_t>(uint16_t value) {
    return _mm256_set1_epi16(value);
}
template <>
inline __m256i _mm256_set1_epiX<uint32_t>(uint32_t value) {
    return _mm256_set1_epi32(value);
}
template <>
inline __m256i _mm256_set1_epiX<uint64_t>(uint64_t value) {
    return _mm256_set1_epi64x(value);
}

template <typename uintX_t>
int myMemcmp(const uintX_t *p1, const uintX_t *p2, size_t size) {
    uint32_t pos = 0;
    size_t idx = 0;

    while (idx < size && !(pos = ~_mm256_movemask_epi8(
                                                       _mm256_cmpeq_epiX<uintX_t>(
                                                                          _mm256_loadu_si256((const __m256i*)(p1 + idx)),
                                                                          _mm256_loadu_si256((const __m256i*)(p2 + idx))
                                                                          )))) idx += sizeof(__m256i) / sizeof(uintX_t);
    if (pos) {
        idx += _tzcnt_u32(pos) / sizeof(uintX_t);
        return idx < size ? p1[idx] - p2[idx] : 0;
    } else {
        return 0;
    }
}

template <typename uintX_t>
const uintX_t* myMemchr(const uintX_t* str, uintX_t c, size_t size) {
    uint32_t pos = 0;
    size_t idx = 0;
    while (idx < size && !(pos = _mm256_movemask_epi8(
                                                      _mm256_cmpeq_epiX<uintX_t>(
                                                                        _mm256_loadu_si256((const __m256i*)(str + idx)),
                                                                        _mm256_set1_epiX(c)
                                                                        )))) idx += sizeof(__m256i) / sizeof(uintX_t);
    if (pos) {
        idx += _tzcnt_u32(pos) / sizeof(uintX_t);
        return str + idx;
    } else {
        return NULL;
    }
}

template <typename uintX_t>
size_t myStrlen(const uintX_t* str) {
    uint32_t pos = 0;
    size_t idx = 0;
    while (!(pos = _mm256_movemask_epi8(
                                        _mm256_cmpeq_epiX<uintX_t>(
                                                          _mm256_loadu_si256((const __m256i*)(str + idx)),
                                                          _mm256_setzero_si256()
                                                          )))) idx += sizeof(__m256i) / sizeof(uintX_t);
    idx += _tzcnt_u32(pos) / sizeof(uintX_t);
    return idx;
}

#include <cstdio>
#include <cstring>

wchar_t str[]  = L"123456788";
wchar_t str1[] = L"123456789";

int main() {
    static_assert(sizeof(wchar_t) == 4, "");

    int a = *(char *)memchr(str, '6', sizeof(str));
    printf("%d", a);
}