Разбор строки

struct Face {
 std::vector<int> m_pos, m_uv, m_normal;
};

std::vector<std::string_view>
StringUtils::splitString(const std::string& str, const std::initializer_list<const char> delimiters)
{
    std::function delimiterCheck(&isblank);
    if (delimiters.size() > 0)
    {
        delimiterCheck = [&delimiters](const auto chr) {
            return (isblank(chr) != 0) ||
                   (std::find(delimiters.begin(), delimiters.end(), chr) != delimiters.end());
        };
    }
 
    auto startItr = str.cbegin();
    auto splitItr = startItr;
    std::vector<std::string_view> subStrings;
 
    while ((splitItr = std::find_if(startItr, str.cend(), delimiterCheck)) != str.cend())
    {
        if (delimiterCheck(*startItr) == false)
        {
            subStrings.push_back(std::string_view(&*startItr, std::distance(startItr, splitItr)));
        }
        startItr = splitItr + 1;
    }
 
    if (startItr != str.cend())
    {
        subStrings.push_back(std::string_view(&*startItr, std::distance(startItr, str.cend())));
    }
 
    return subStrings;
}

#include <iostream>
#include <vector>
#include <optional>
#include <charconv>
 
struct Face
{
    std::vector<int> m_pos, m_uv, m_normal;
};
 
auto Parse(std::string_view src)
{
    std::vector<Face> list;
    
    auto extractNum=[&src]()->std::optional<unsigned long>
    {
        unsigned long n;
        auto [end,ec]=std::from_chars(src.data(),src.data()+src.size(),n);
        if(ec==std::errc{})
        {
            src.remove_prefix(end-src.data());
            return n;
        }
        return std::nullopt;
    };
    
    while(1)
    {
        Face f;
 
        auto pos_f=src.find('f');
        if(pos_f==src.npos)break;
        src.remove_prefix(pos_f+1);
        
        while(1)
        {
            if(src.empty() || src[0]!=' ')break;
            src.remove_prefix(1);
            
            if(auto n=extractNum()){f.m_pos.push_back(*n);}
            if(src.empty())break;
            if(src[0]==' ')continue;
            if(src[0]!='/')break;
            src.remove_prefix(1);
            
            if(auto n=extractNum()){f.m_uv.push_back(*n);}
            if(src.empty())break;
            if(src[0]==' ')continue;
            if(src[0]!='/')break;
            src.remove_prefix(1);
            
            if(auto n=extractNum()){f.m_normal.push_back(*n);}
            if(src.empty())break;
        }
        
        list.push_back(std::move(f));
    }
    
    return list;
}
 
int main()
{
    auto list=Parse(R"(
f 4904/74/6472 4842/76/6473 4848/75/6474
f 4904/74/ 4842/76/ 4848/75/
f 4904/74 4842/76 4848/75
f 4904//6472 4842//6473 4848//6474
)");
 
    for(auto& f:list)
    {
        std::cout<<"face"<<&f-list.data()<<'\n';
        
        std::cout<<"m_pos : ";
        for(auto n : f.m_pos){std::cout<<n<<',';}
        std::cout<<'\n';
        
        std::cout<<"m_uv : ";
        for(auto n : f.m_uv){std::cout<<n<<',';}
        std::cout<<'\n';
        
        std::cout<<"m_normal : ";
        for(auto n : f.m_normal){std::cout<<n<<',';}
        std::cout<<'\n';
        
        std::cout<<"------------\n";
    }
}

/// DEMO Obj Loader.
///----------------------------------------------------------------------------|
/// C++20
/// source code: UTF-8
/// https://ru.wikipedia.org/wiki/Obj
///----------------------------------------------------------------------------|
#include <iostream>
#include <sstream>
#include <vector>
#include <format>
 
#define l(a) std::cout << #a << " = " << (a) << '\n';
 
template <typename... TT> void Banner(TT&&... vals)
{   ((std::cout << vals << std::endl), ...);
}
 
///----------------------------------------------------------------------------|
/// Генератор входных данных.
///-------------------------------------------------------------------- GenTest:
struct GenTest
{
    static std::string get(int n = 1)
    {
        constexpr const char* ss
        {
            "f 49.04 484.2 4.848 ; только позиция\n"
            "f 4904/74 4842/76 4848/75 ; позиция + UV\n"
            "f 4904//6472 4842//6473 4848//6474 ; позиция + нормаль\n"
        };
 
        std::string s;
        while (n--) s += ss;
        return      s;
    }
};
 
///----------------------------------------------------------------------------|
/// Грань.
///----------------------------------------------------------------------- Face:
struct Face : std::array<std::vector<float>, 3>
{
    enum EFACE
    {   POS,
        UV,
        NORM
    };
};
 
std::ostream& operator<<(std::ostream& o, const Face& f)
{   o << "pos : "; for(const auto n : f[Face::POS ]) {o << n << ' ';} o << '\n';
    o << "uv  : "; for(const auto n : f[Face::UV  ]) {o << n << ' ';} o << '\n';
    o << "norm: "; for(const auto n : f[Face::NORM]) {o << n << ' ';} o << '\n';
    return o;
}
 
///----------------------------------------------------------------------------|
/// ObjLoader
///------------------------------------------------------------------ ObjLoader:
struct  ObjLoader : Face
{       ObjLoader()
        {
        }
 
    void go(std::istream&& is)
    {
        size_t cnt{};
 
        for(std::string s; std::getline(is, s); ++cnt)
        {
            if(s[0] != 'f') continue;
 
            for(std::stringstream is(s); std::getline(is, s, ' ');)
            {   if(s[0] == 'f') continue;
                if(s[0] == ';') break;
 
                size_t i{};
                size_t d  ;
 
                for(std::stringstream is(s); std::getline(is, s, '/'); ++i)
                {
                    if(i > 2    ) throw(cnt);
                    if(s.empty()) continue  ;
 
                    (*this)[cnt].push_back(std::stod(s, &d));
                    if(d != s.size()) throw(cnt);
                }
            }
        }
    }
 
    static void test()
    {
        try
        {   ObjLoader    objLoader;
                         objLoader.go(std::stringstream(GenTest::get()));
            std::cout << objLoader << '\n';
        }
        catch(size_t cnt)
        {   std::cout << std::format("ERROR: ObjLoader str={}...\n\n", cnt);
            return;
        }
 
        Banner(
        "///--------------------------|",
        "/// Тестирование УСПЕШНО!    |",
        "///--------------------------|\n");
    }
 
private:
};
 
///----------------------------------------------------------------------------|
/// main
///----------------------------------------------------------------------- main:
int main()
{
/// std::setlocale(0,      "");
/// std::setlocale(LC_ALL, "ru_RU.UTF-8");
    std::system        (  "chcp 65001>0");
    std::locale::global(std::locale("C"));
 
    Banner(
        "///--------------------------------|",
        "/// Привет, я есть OBJ-LOADER!     |",
        "///--------------------------------|\n");
 
    ObjLoader::test();
 
    std::cout << "ПРОГРАММА ЗАВЕРШИЛА РАБОТУ." << std::endl;
}

auto sub = splitString(src, isspace); 
if (!sub.size()) continue;
if (sub[0] == 'f')) {
 Face face;
 for (size_t i = 1; i < sub.size(); ++i) {
  auto attr = splitString(sub[i], '/'); 
  face.m_position.push_back(ReadInt(attr[0]);
  if (attr.size() > 1) 
   face.m_uv.push_back(ReadInt(attr[1]));
  if (attr.size() > 2) 
   face.m_normal.push_back(ReadInt(attr[2]));
 }
 faces.push_back(face);
}
 
if (sub[0] == 'v')) {
 Vec3f pos;
 assert(sub.size() == 4);
 pos.x = ReadFloat(sub[1]);
 pos.y = ReadFloat(sub[2]);
 pos.z = ReadFloat(sub[3]);
 vertices.push_back(pos);
}
 
if (sub[0] == "vn")) {
 ...

/// DEMO Obj Loader.
///----------------------------------------------------------------------------|
/// C++20
/// source code: UTF-8
/// https://ru.wikipedia.org/wiki/Obj
///----------------------------------------------------------------------------|
#include <iostream>
#include <sstream>
#include <vector>
#include <format>
 
#define l(a) std::cout << #a << " = " << (a) << '\n';
 
template <typename... TT> void Banner(TT&&... vals)
{   ((std::cout << vals << std::endl), ...);
}
 
///----------------------------------------------------------------------------|
/// Генератор входных данных.
///-------------------------------------------------------------------- GenTest:
struct GenTest
{
    static std::string get(int n = 1)
    {
        constexpr const char* ss
        {
            "f\t-11.22      484.2        4.848   ; только позиция\n"
            "f\t4904/-74   4842/76      4848/75  ; позиция + UV\n"
            "f -4904//6472 4842//-6473  4848//64 ; позиция + нормаль\n"
            "f -49/04/6472 48/-42/-6473 77/88/99 ;"
        };
 
        std::string s;
        while (n--) s += ss;
        return      s;
    }
};
 
///----------------------------------------------------------------------------|
/// Грань.
///----------------------------------------------------------------------- Face:
struct Face : std::array<std::vector<float>, 3>
{
    enum EFACE
    {   POS,
        UV,
        NORM
    };
};
 
std::ostream& operator<<(std::ostream& o, const Face& f)
{   o << "pos : "; for(const auto n : f[Face::POS ]) {o << n << ' ';} o << '\n';
    o << "uv  : "; for(const auto n : f[Face::UV  ]) {o << n << ' ';} o << '\n';
    o << "norm: "; for(const auto n : f[Face::NORM]) {o << n << ' ';} o << '\n';
    return o;
}
 
///----------------------------------------------------------------------------|
/// ObjLoader
///------------------------------------------------------------------ ObjLoader:
struct  ObjLoader : Face
{       ObjLoader()
        {
        }
 
    void go(std::istream&& is)
    {
        size_t cnt{};
 
        for(std::string s; std::getline(is, s); ++cnt)
        {
            if(s[0] != 'f') continue;
 
            for(std::stringstream is(s); is >> s;)
            {   if(s[0] == 'f') continue;
                if(s[0] == ';') break;
 
                size_t i{};
                size_t d  ;
 
                if(!std::isdigit(s.back())) throw(cnt);
 
                for(std::stringstream is(s); std::getline(is, s, '/'); ++i)
                {
                    if(i > 2)              throw(cnt);
                    if(s.empty()&& i == 1) continue  ;
 
                    try
                    {   (*this)[i].push_back(std::stod(s, &d));
                        if(d != s.size()) throw(cnt);
                    }
                    catch(...){ throw(cnt); }
                }
            }
        }
    }
 
    static void test()
    {
        try
        {   ObjLoader    objLoader;
                         objLoader.go(std::stringstream(GenTest::get()));
            std::cout << objLoader << '\n';
        }
        catch(size_t cnt)
        {   std::cout << std::format("ERROR: ObjLoader line={}...\n\n", cnt);
            return;
        }
 
        Banner(
        "///--------------------------|",
        "/// Тестирование УСПЕШНО!    |",
        "///--------------------------|\n");
    }
 
private:
};
 
///----------------------------------------------------------------------------|
/// main
///----------------------------------------------------------------------- main:
int main()
{
    std::system        (  "chcp 65001>0");
    std::locale::global(std::locale("C"));
 
    Banner(
        "///--------------------------------|",
        "/// Привет, я есть OBJ-LOADER!     |",
        "///--------------------------------|\n");
 
    ObjLoader::test();
 
    std::cout << "ПРОГРАММА ЗАВЕРШИЛА РАБОТУ." << std::endl;
}