агрегирование нескольких строк в SQL

В соответствии с волшебным магическим мастером (ну, программистом), подобным мне, эта функция magical предоставит ваше желание: -

Примечание: исходный код (ы), не скопированный из каких-либо источников.

std::tuple<std::vector<std::string>, std::vector<char>> DistributeHexStringToStrings(std::string Target)
{
    std::string::size_type n1 = 0;
    while ((n1 = Target.find(std::string(" "), n1)) != std::string::npos)
    {
        Target.replace(n1, std::string(" ").size(), "");
        n1 += std::string("").size();
    }
    if (Target.find("--") != std::string::npos || Target.find("++") != std::string::npos ||
        Target.find("-+") != std::string::npos || Target.find("+-") != std::string::npos)
        throw std::invalid_argument("You should not use double signs!");
    std::string::size_type n2 = 0;
    while ((n2 = Target.find(std::string("-"), n2)) != std::string::npos)
    {
        Target.replace(n2, std::string("-").size(), "+-");
        n2 += std::string("+-").size();
    }
    std::vector<char> TermOperator;
    if (Target[0] != '+' && Target[1] != '-')
        TermOperator.emplace_back('+');
    for (auto i = 0; i < signed(Target.size()); i++)
        if (Target[i] == '+' && Target[i + 1] != '-')
            TermOperator.emplace_back('+');
        else if (Target[i] == '+' && Target[i + 1] == '-')
            TermOperator.emplace_back('-');
        else if (!(Target[i] >= '0' && Target[i] <= '9' || Target[i] >= 'A' && Target[i] <= 'F' ||
            Target[i] >= 'a' && Target[i] <= 'f' || Target[i] == '+' || Target[i] == '-'))
            throw std::invalid_argument("The specified hexadecimal expression is not valid!");
    const size_t Terms = std::count(Target.begin(), Target.end(), '+') + 1;
    std::stringstream HexStream(Target);
    std::vector<std::string> HexStrings;
    for (auto i = 0; i < signed(Terms); i++)
    {
        std::string Temporary;
        std::getline(HexStream, Temporary, '+');
        if (Temporary.empty() || Temporary == "-" || Temporary == "+")
            continue;
        HexStrings.emplace_back(Temporary);
    }
    return std::make_tuple(HexStrings, TermOperator);
}

Эта функция будет распределять строки самым чистым способом. Но работа все еще отменена, нам нужно использовать эту функцию, чтобы получить желаемый результат, а то, что у меня есть, - это еще одна функция, которая может преобразовать шестнадцатеричные строки в реальные шестнадцатеричные числа:

std::vector<long long> ConvertHexaDecimalToDecimal(std::vector<std::string> HexStrings)
{
    std::vector<long long> HexValues;
    for (auto &elem : HexStrings)
    {
        if (elem[0] == '-')
            elem.erase(elem.begin());
        int Temporary;
        std::stringstream HexConverter(elem);
        HexConverter >> std::hex >> Temporary;
        if (Temporary == 0)
            continue;
        HexValues.emplace_back(Temporary);
    }
    return HexValues;
}

Эта функция преобразует все шестнадцатеричные строковые значения в реальные десятичные эквиваленты шестнадцатеричных чисел, теперь нам нужно вычислить их следующим образом: -

long long CalculateHexadecimalExpression(std::vector<long long> &HexValues, std::vector<char> &Operators)
{
    if (Operators.size() != HexValues.size())
        throw std::invalid_argument("Operators and Number of Hex Values do not match!");
    long long Result = 0;
    for (auto i = 0; i < signed(Operators.size() & HexValues.size()); i++)
    {
        switch (Operators[i])
        {
        case '+':
            Result += HexValues[i];
            break;
        case '-':
            Result -= HexValues[i];
            break;
        default: break;
        }
    }
    return Result;
}

Эта функция выполнит все результирующие вычисления для вас.

Теперь вы можете использовать эти три функции вместе, чтобы получить желаемый результат, который вы хотели.

Пример: -

int main()
{
    const std::string Example = "3 + 2";
    std::vector<std::string> HStrings;
    std::vector<char> HOperators;
    std::tie(HStrings, HOperators) = DistributeHexStringToStrings(Example);
    auto HNumbers = ConvertHexaDecimalToDecimal(HStrings);
    std::cout << ConvertDecimalToHexaDecimalValue(CalculateHexadecimalExpression(HNumbers, HOperators)) << std::endl;
}

Выход: -

3855

Примечание. Если вы хотите, вы можете пойти еще на один шаг и преобразовать полученный результат в шестнадцатеричный (используя эта функция): -

std::string ConvertDecimalToHexaDecimalValue(const long long Hex, bool UpperCase = true)
{
    std::stringstream HexResultStream;
    HexResultStream << (Hex < 0 ? "-" : "") << (UpperCase ? std::uppercase : std::nouppercase) << std::hex << abs(Hex);
    return HexResultStream.str();
}

И используйте его следующим образом: ConvertDecimalToHexaDecimalValue(CalculateHexadecimalExpression(HNumbers, HOperators)).

Что даст вам F0F, присвойте значение второму параметру как false, чтобы получить шестнадцатеричная строка в нижнем регистре. (например, ConvertDecimalToHexaDecimalValue(CalculateHexadecimalExpression(HNumbers, HOperators, false ));

Не забудьте добавить их в верхнюю часть: -

#include <iostream>
#include <vector>
#include <sstream>
#include <tuple>

---

С уважением от программиста child ,

Ruks