Очистить поток std::stringstream

std::stringstream ss_1(leftPPF);

ss_1.clear();

#include <iostream>
#include <conio.h>
#include <string>
#include <algorithm>
#include <ctype.h>
#include <sstream>
#include <map>
 
std::string rightPPF;
std::string leftPPF;
std::string resultLeft;
std::string resultRight;
 
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
void SetRussianLocale() { setlocale(LC_ALL, "Russian"); }
void tips();
void clearSpace();
void clearAbc();
 
 
int main() {
 
    SetRussianLocale();
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    tips();
    ////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////
    clearAbc();
    std::stringstream ss_11(rightPPF);
    std::string s_11;
    std::stringstream ss_22(leftPPF);
    std::string s_22;
 
    while (!ss_11.eof()) {
 
        std::getline(ss_22, s_22, ',');
        std::getline(ss_11, s_11, ',');
        if (s_11.length() == 1) {
 
            if (s_22.length() == 1) {
                // zikl for
                if (s_22.find(s_11[0]) != std::string::npos) {
 
                    std::cout << leftPPF << "=>" << rightPPF << "\t - строка доказана" << std::endl;
                    break;
                }
                else {
                    std::cout << std::endl;
                    leftPPF.push_back(',');
                    leftPPF.push_back(s_11[0]);
                    size_t p1;
                    if (p1 = rightPPF.find(s_11[0]) != std::string::npos) {
 
                        rightPPF.erase(p1 - 1, 2);
                    }
                    //rightPPF.erase(rightPPF.begin());
                    //rightPPF.erase(rightPPF.begin());
                    std::cout << leftPPF << "=>" << rightPPF << "\tSwap";
                    break;
                }
            }
        }
    }
    ss_22.str(rightPPF);
    ss_22.clear();
    ss_11.str(rightPPF);
    ss_11.clear();
    
    std::stringstream ss_33(leftPPF);
    std::string s_33;
 
    while (!ss_33.eof()) {
 
        std::cout << "HIIIIII" << std::endl;
        std::cout << std::endl;
        std::getline(ss_33, s_33, ',');
 
        if (s_33.length() == 3) {
 
            std::cout << "TIIIII" << std::endl;
            std::cout << std::endl;
            if (leftPPF.find(s_33) != std::string::npos) {
 
                std::cout << std::endl;
                std::cout << s_33;
                std::cout << std::endl;
                if (rightPPF.find(s_33[0]) != std::string::npos) {
 
                    if (s_33[2] == toupper(s_33[2])) {
 
                        rightPPF.push_back(',');
                        rightPPF.push_back(tolower(s_33[2]));
                        leftPPF.push_back(',');
                        leftPPF.push_back(s_33[0]);
                        size_t p2;
                        if (p2 = leftPPF.find(s_33[0]) != std::string::npos) {
 
                            leftPPF.erase(p2 + 1, 4);
                        }
                    }
                    else {
 
                        rightPPF.push_back(',');
                        rightPPF.push_back(toupper(s_33[2]));
                        leftPPF.push_back(',');
                        leftPPF.push_back(s_33[0]);
                        size_t p3;
                        if (p3 = leftPPF.find(s_33[0]) != std::string::npos) {
 
                            leftPPF.erase(p3 + 1, 4);
                        }
                    }
                }
                else {
 
                    if (s_33[0] == toupper(s_33[0])) {
 
                        rightPPF.push_back(',');
                        rightPPF.push_back(tolower(s_33[0]));
                        leftPPF.push_back(',');
                        leftPPF.push_back(s_33[2]);
                        size_t p4;
                        if (p4 = leftPPF.find(s_33[0]) != std::string::npos) {
 
                            leftPPF.erase(p4 + 1, 4);
                        }
                    }
                    else {
 
                        rightPPF.push_back(',');
                        rightPPF.push_back(toupper(s_33[0]));
                        leftPPF.push_back(',');
                        leftPPF.push_back(s_33[2]);
                        size_t p5;
                        if (p5 = leftPPF.find(s_33[0]) != std::string::npos) {
 
                            leftPPF.erase(p5 + 1, 4);
                        }
                    }
                }
                std::cout << leftPPF << "=>" << rightPPF << "\tssss";
                std::cout << std::endl;
                clearAbc();
                break;
            }
        }
        else {
            std::stringstream ss_44(rightPPF);
            std::string s_44;
            std::stringstream ss_55(leftPPF);
            std::string s_55;
 
            while (!ss_44.eof()) {
 
                std::getline(ss_55, s_55, ',');
                std::getline(ss_44, s_44, ',');
                if (s_44.length() == 1) {
 
                    if (s_55.length() == 1) {
 
                        if (s_55.find(s_44[0]) != std::string::npos) {
 
                            std::cout << leftPPF << "=>" << rightPPF << "\t -Теорема доказана" << std::endl;
                            break;
                        }
                        else {
                            std::cout << std::endl;
                            std::cout << leftPPF << "=>" << rightPPF << "\t -Теорема опровергается" << std::endl;
                            break;
                        }
                    }
                }
            }
 
            ss_55.str(rightPPF);
            ss_55.clear();
            ss_44.str(rightPPF);
            ss_44.clear();
        }
    }
 
    std::cout << std::endl;
 
    std::cout << leftPPF << "=>" << rightPPF << "\tmain:end";
    ss_33.str(rightPPF);
    ss_33.clear();
    
 
    _getch();
    return 0;
}
 
 
void tips() {
 
    std::cout << "\t\t\t\tИнструкция юзера.\n";
    std::cout << "\t\t\t\t^ - конъюнкция\n";
    std::cout << "\t\t\t\tv - дизъюнкция\n";
    std::cout << "\t\t\t\t> - импликация\n";
    std::cout << "\t\t\t\t, - запятая\n";
    std::cout << "\t\t\t\tx - инверсия X\n";
    std::cout << "\t\t\t\t! - общая инверсия(перед формуло)\n";
    std::cout << " Пожалуйста, вводите символы латинских букв и изображенных логических операций!\n\n\n";
    //(A^B)v(C>D)~B^C
    // шаг 1!
    std::cout << "Введите значения по отношению!";
    std::cout << "\nВведите отношение слева: ";
    std::cin >> leftPPF;
    std::cout << "\nВведите отношение справа: ";
    std::cin >> rightPPF;
 
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
void clearSpace() {
 
    // исключение пробела
    for (unsigned int i = 0; i < leftPPF.length(); ++i)
 
        if (leftPPF[i] == ' ')
 
            leftPPF.erase(leftPPF.begin() + i);
 
    for (unsigned int j = 0; j < rightPPF.length(); ++j)
 
        if (rightPPF[j] == ' ')
 
            rightPPF.erase(rightPPF.begin() + j);
 
    std::cout << leftPPF << "=>" << rightPPF << "\tClearSpace";
    std::cout << std::endl;
}
 
void clearAbc() {
    // шаг 12!
    // первая строка
    std::stringstream ss_1(leftPPF);
 
    std::map<char, bool> chars_1;
    std::string s_1;
    while (!ss_1.eof()) {
 
        std::getline(ss_1, s_1, ',');
        if (s_1.length() == 1) {
 
            if (chars_1.find(s_1[0]) == chars_1.end())
 
                chars_1[s_1[0]] = false;
        }
        else /*if(s.lenght()==3*/ {
 
            chars_1[s_1[0]] = true;
            chars_1[s_1[2]] = true;
        }
    }
 
    ss_1.str(leftPPF);
    ss_1.clear();
 
 
    while (!ss_1.eof()) {
 
        std::getline(ss_1, s_1, ',');
        if (s_1.length() == 1) {
 
            if (chars_1[s_1[0]])
 
                continue;
            chars_1[s_1[0]] = true;
        }
        resultLeft += s_1 + ",";
    }
    if (resultLeft.length())
 
        resultLeft.resize(resultLeft.length() - 1);
    
    
    // вторая строка
    std::stringstream ss_2(rightPPF);
 
    std::map<char, bool> chars_2;
    std::string s_2;
    while (!ss_2.eof()) {
 
        std::getline(ss_2, s_2, ',');
        if (s_2.length() == 1) {
 
            if (chars_2.find(s_2[0]) == chars_2.end())
 
                chars_2[s_2[0]] = false;
        }
        else /*if(s.lenght()==3*/ {
 
            chars_2[s_2[0]] = true;
            chars_2[s_2[2]] = true;
        }
    }
    ss_2.str(rightPPF);
    ss_2.clear();
 
    while (!ss_2.eof()) {
 
        std::getline(ss_2, s_2, ',');
        if (s_2.length() == 1) {
 
            if (chars_2[s_2[0]])
 
                continue;
            chars_2[s_2[0]] = true;
        }
        resultRight += s_2 + ",";
    }
    if (resultRight.length())
 
        resultRight.resize(resultRight.length() - 1);
    
    leftPPF = resultLeft;
    rightPPF = resultRight;
    std::cout << resultLeft << "=>" << resultRight << "\tClearABC: r,r";
    std::cout << std::endl;
 
    std::cout << leftPPF << "=>" << rightPPF << "\tClearABC: l,f";
    std::cout << std::endl;
    
}