dustpg大神给我的代码，总有一天我要完全读懂！

帖子：http://bbs.csdn.net/topics/391835837

PS：赋值字符串技巧：如果是中间的一段字符串（末尾没有 '\0' 所以不能直接调用 strcpy），

可以先 memcpy，然后将 buff 的最后一个 char 赋值为 '\0'，就不用调用 memset 或 bzero 对整块 buff 清零了

要效率就肯定要加限制, 这是我的限制:
1. 使用时要保证原字符串对象的有消息 -> 可以直接使用原来的数据避免复制
2. 使用‘字符指针’+‘长度模式, 虽然C风格的字符串是用null字符结尾, 但是世界上又不是
全是只给个字符指针, 比如fwrite要给长度, 可以代替fprintf, 
Windows有些API也是需要给长度的, 这样避免字符串的复制
3.实在需要null结尾指针, 
3.1 可以使用std::string::assign,
3.2 也可以提供支持, 但是要尽可能的少用，因为用一次就复制一次

代码如下, SubString ::get的第二个参数是一个lambda,
A. 如果这个lambda有两个参数， 则认为是(const char* str, size_t len), 参考上面的行为2
B. 如果这个lambda有一个参数， 则认为是(const char* str), 参考上面的行为3

#include <vector>
#include <string>
#include <cstdint>

// type helper with c++ tuple
template <typename T> struct type_helper : public type_helper<decltype(&T::operator())> {};
// type helper
template <typename ClassType, typename ReturnType, typename... Args>
struct type_helper<ReturnType(ClassType::*)(Args...) const> {
    // number of arguments
    enum : size_t { arity = sizeof...(Args) };
};

class SubString {
    static constexpr size_t BUFFER_LENGTH = 4096;
    using SUBDATA = uint32_t;
    using String = std::string;
    struct SUBSTRDATA { SUBDATA offset; SUBDATA length; };
    using Vector = std::vector<SUBSTRDATA>;
private:
    struct string_helper {
        string_helper(const char* str, size_t len) noexcept {
            if (len >= BUFFER_LENGTH) {
                data = reinterpret_cast<char*>(::malloc(len + 1));
            }
            if (data) {
                ::memcpy(data, str, sizeof(char) * len);
                data[len] = 0;
            }
        }
        ~string_helper() noexcept { if (data && data != buffer) ::free(data); }
        char*   data = buffer;
        char    buffer[BUFFER_LENGTH];
    };

    template<size_t ArgNum> struct get_helper{};
    template<> struct get_helper<1> {
        template<typename T>
        static auto get(const char* str, size_t len, T lam) {
            string_helper data(str, len);
            return lam(data.data);
        }
    };
    template<> struct get_helper<2> {
        template<typename T>
        static auto get(const char* str, size_t len, T lam) { return lam(str, len); }
    };
public:
    // split
    auto split(const String& src, const char* token) {
        vc.clear();
        data = &src;
        String::size_type end = 0, begin = 0;
        auto token_length = std::strlen(token);
        SUBSTRDATA sbdata;
        while (end != String::npos) {
            end = src.find(token, begin);
            sbdata.offset = SUBDATA(begin);
            if (String::npos == end) {
                sbdata.length = SUBDATA(src.length() - begin);
            } 
            else {
                sbdata.length = SUBDATA(end - begin);
            }
            vc.push_back(sbdata);
            begin = end + token_length;
        }
    }
    // size
    auto size() { return vc.size(); }
    // get
    template<typename T> auto get(size_t index, T func) { 
        auto& ele = vc[index];
        const char* str = data->data() + ele.offset;
        return get_helper<type_helper<T>::arity>::get(str, size_t(ele.length), func); 
    }
private:
    //
    const String*   data = nullptr;
    //
    Vector          vc;
};

auto main() ->int {
    std::string str = "ABCDEFABCDEFABCDEF";
    {
        SubString sst;
        sst.split(str, "CD");
        for (size_t i = 0; i < sst.size(); ++i) {
            sst.get(i, [](const char* str, size_t len) noexcept {
                for (size_t j = 0; j < len; ++j) std::putchar(str[j]);
                std::putchar('\r');
                std::putchar('\n');
            });
        }
        std::printf("============\r\n");
        for (size_t i = 0; i < sst.size(); ++i) {
            sst.get(i, [](const char* str) noexcept {
                std::printf("%s\r\n", str);
            });
        }
    }
    return 0;
}

--EOF--