实现ipv4和ipv6转换

do {
    char cc = *cp;
    if (cc >= '0' && cc <= '9') {
        acc = acc * 10 + (cc - '0');
    }
    else if (cc == '.' || cc == '\0') {
        if (++dots > 3 && cc == '.') {
            return 0;
        }
        /* Fall through */

        if (acc > 255) {
            return 0;
        }

        addr += (acc << (index * 8));//各平台统一
        //从左往右，低位放
        //addr = addr << 8 | acc; // 这句是精华,每次将当前值左移八位加上后面的值
        ++index;
        acc = 0;
    }
} while (*cp++);

// Normalize the address 
if (dots < 3) {
    addr <<= 8 * (3 - dots);
}

ap = addr;
return 1;

constexpr  char  xdigits_l[] = "0123456789abcdef";
constexpr  char  xdigits_u[] = "0123456789ABCDEF";
const      char* xdigits = nullptr;
const      char* curtok = nullptr;
constexpr  int  NS_IN6ADDRSZ = 16;
constexpr   int NS_INT16SZ = 2;
std::uint8_t tmp[NS_IN6ADDRSZ] = { 0 };
std::uint8_t* tp = tmp;
std::uint8_t* endp = nullptr;
std::uint8_t* colonp = nullptr;
endp = tp + NS_IN6ADDRSZ;

/* Leading :: requires some special handling. */
if (*src == ':') {
    if (*++src != ':') {
        return 0;
    }
}

int              seen_xdigits = 0;
std::size_t    val = 0;
char  ch = 0;
while ((ch = *src++) != '\0') {
    const char* pch = nullptr;

    if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL) {
        pch = strchr((xdigits = xdigits_u), ch);
    }

    if (pch != NULL) {
        val <<= 4;
        val |= (pch - xdigits);
        if (++seen_xdigits > 4) {
            return 0;
        }

        continue;
    }

    if (ch == ':') {
        curtok = src;
        if (!seen_xdigits) {
            if (colonp != nullptr) {
                return 0;
            }

            colonp = tp;
            continue;
        }
        else if (*src == 0) {
            return 0;
        }

        if (tp + NS_INT16SZ > endp) {
            return 0;
        }

        *tp++ = (u_char)(val >> 8) & 0xff;    //放在高位上
        *tp++ = (u_char)val & 0xff; //放在低位上
        seen_xdigits = 0;
        val = 0;
        continue;
    }

    if (ch == '.' && ((tp + 4) <= endp)) {
        uint32_t value = 0;
        if (inet4_pton(curtok, value)) {
            unsigned char* buf = (unsigned char*)&value;
            memcpy(tp, buf, 4);
            tp += 4;
            seen_xdigits = 0;
            break;  /*%< '\\' was seen by inet_pton4(). */
        }
    }

    return 0;
}

if (seen_xdigits) {
    if (tp + NS_INT16SZ > endp) {
        return 0;
    }

    *tp++ = (u_char)(val >> 8) & 0xff;
    *tp++ = (u_char)val & 0xff;
}

if (colonp != NULL) {
    if (tp == endp) {
        return 0;
    }

    const std::size_t n = tp - colonp;
    for (int i = 1; i <= n; i++) {
        endp[-i] = colonp[n - i];
        colonp[n - i] = 0;
    }

    tp = endp;
}

if (tp != endp) {
    return 0;
}

memcpy(dst, tmp, NS_IN6ADDRSZ);

return 1;

memset(words, '\0', sizeof words);
for (int i = 0; i < NS_IN6ADDRSZ; i += 2) {
    words[i / 2] = (src[i] << 8) | src[i + 1];
}

best.base = -1;
cur.base = -1;
best.len = 0;
cur.len = 0;
for (int i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) {
    if (words[i] == 0) {
        if (cur.base == -1) {
            cur.base = i, cur.len = 1;
        }
        else {
            cur.len++;
        }
    }
    else {
        if (cur.base != -1) {
            if (best.base == -1 || cur.len > best.len) {
                best = cur;
            }

            cur.base = -1;
        }
    }
}
if (cur.base != -1) {
    if (best.base == -1 || cur.len > best.len) {
        best = cur;
    }
}
if (best.base != -1 && best.len < 2) {
    best.base = -1;
}

/*
 * Format the result.
 */
char* tp = tmp;
for (int i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++) {
    /* Are we inside the best run of 0x00's? */
    if (best.base != -1 && i >= best.base &&
        i < (best.base + best.len)) {
        if (i == best.base) {
            *tp++ = ':';
        }

        continue;
    }
    /* Are we following an initial run of 0x00s or any real hex? */
    if (i != 0) {
        *tp++ = ':';
    }

    /* Is this address an encapsulated IPv4? */
    if (i == 6 && best.base == 0 &&
        (best.len == 6 || (best.len == 5 && words[5] == 0xffff))) {
        std::string temp;
        temp.resize(20);
        memcpy(&temp[0], (char*)src + 12, 4);

        uint32_t value = 0;
        uint32_t* ptr = (uint32_t*)temp.data();
        value = *ptr;

        inet4_ntop(value, temp);
        std::size_t len = strlen(temp.c_str());
        memcpy(tp, temp.c_str(), len);
        tp += len;
        break;
    }

    std::stringstream sstream;
    sstream << std::hex << words[i];
    std::size_t len = strlen(sstream.str().c_str());
    memcpy(tp, sstream.str().c_str(), len);
    tp += len;
}
/* Was it a trailing run of 0x00's? */
if (best.base != -1 && (best.base + best.len) == (NS_IN6ADDRSZ / NS_INT16SZ)) {
    *tp++ = ':';
}

*tp++ = '\0';

std::size_t len = strlen(tmp);
dst.resize(len);
memcpy(&dst[0], tmp, len);

inet4_ntop(value, addr100);
std::cout << addr100 << std::endl;

///*******ipv6测试*******/
//char* addr1 = _strdup("2000:0000:0000:0000:0001:2345:6789:abcd");
//struct in6_addr ip;
//struct in6_addr ip1;
//std::string str;
//std::string sss;
inet_pton(AF_INET6, addr1, &ip);
//inet6_pton(addr1, (uint8_t*)&ip.u);
//ip1.u = ip.u;
inet6_ntop1(ip.u.Byte, str);

//sss.resize(100);
//inet_ntop(AF_INET6, &ip1, &sss[0], INET6_ADDRSTRLEN);