Сравнение символов со строкой

std::vector<std::string> RegConstants;

void RegImmConstantFinderInVectorOfRegConstants(std::string RegName)
            {
                if (RegConstants.size() > 0)
                {
                    for (auto it = RegConstants.begin(); it < RegConstants.end(); it++)
                    {
                        int64_t Index = std::distance(RegConstants.begin(), it);
                        
                        char* CharStringWithTempVarFromReg = new char[RegConstants[Index].length() + 1];
                        strcpy(CharStringWithTempVarFromReg, RegConstants[Index].c_str());
 
                        char* CharRegName = new char[RegName.length() + 1];
                        strcpy(CharRegName, RegName.c_str());
                        for (int j = 0; j < RegConstants[Index].length(); j++)
                        {
                            for (int v = 0; v < RegName.length(); v++)
                            {
                                if (CharStringWithTempVarFromReg[j] == CharRegName[v])
                                {
                                    fmt::print("{}", RegName);
                                }
                            }
                        }
                    }
                }
            }

bool RegImmConstantFinderInVectorOfRegConstants(std::string RegName)
            {
                
                if (RegConstants.size() > 0)
                {
                    int i = 0; i++;
 
                    auto it{ std::binary_search(RegConstants.begin(), RegConstants.end(), RegName) };
                    std::cout << "Element: " << i;
 
                    return it;
                }
                return false;
            }
 
std::binary_search(RegConstants.begin(), RegConstants.end(), RegImmConstantFinderInVectorOfRegConstants(RegName));

void RegImmConstantFinderInVectorOfRegConstants(std::vector<std::string> &vec, std::string RegName)
    {
if (vec.size() > 0)
    {
for (int Index = 0; Index < vec.size(); Index++)
        {
            size_t pos = vec[Index].find(RegName);
if (pos != std::string::npos)
std::cout << "Found at Index = " << Index << "     Found at pos = " << pos + 1 << "\n";
            
        }   }      }
 
 
int _tmain()
{
std::vector<std::string> RegConstants
    { "My mother is very kind",// 0
                           "kjn tyuio",// 1
      "Then she usually reads",// 2
                       "Hello world",// 3
"She has a very pleasant smile",// 4
      "very hardworking man",// 5
"There are five of us – my parents",
    "fgtyu",
    "fghjk" };
 
RegImmConstantFinderInVectorOfRegConstants(RegConstants,"pleasant");
 
std::cin.get();
    return 0;
}

for (int Index = 0; Index < vec.size(); Index++)
        {
            size_t pos = vec[Index].find(RegName);
if (pos != std::string::npos)
std::cout << "Found at Index = " << Index << "     Found at pos = " << pos + 1 << "\n";
            
        }   }

void RegImmConstantFinderInVectorOfRegConstants(const std::vector<std::string> &vec, const std::string &RegName) {
 for_each(vec.begin(),vec.end(),[&RegName](const string &val) {
   size_t pos =  val.find(RegName);
   if( pos != string::npos) {
     cout << "Found at pos = " << pos + 1 << "\n";
   }
 });
}

else {// Вставить одну строчку в массив (Удлиннить массив , если короткий)
                if (strlen(ms) + strlen(msg.c_str()) > volume-2){//<==== volume-2 подбирал, что бы добавление одного символа,
                    Beep(3000, 5); Sleep(5); Beep(3000, 5);//      вызывало срабатывание.(а то добавление вешало)
                    int length_share = strlen(ms);
                    // strlen(ms) -- Брать до realloc... После уже не покажет. там будет мусор
                    volume = (length_share + strlen(msg.c_str()) + 128);// Цифра 64 от фонаря, на ебанутый текст
                    ms = (char*)realloc(ms, volume);
                    *(ms + length_share) = '\0';//<==== После realloc, главное вставить на правильное место ноль. !!!
                    //memset(ms + length_share, 0, volume - length_share);//Обнулять пытался
                }
                strcat(ms, msg.c_str()); strcat(ms, "\r\n");// Что бы сделать в массив strcat, там должен стоять ноль

            void RegImmConstantFinderInVectorOfRegConstants(std::string RegName, Language_Letters Language_Letters, ZydisDisassembledInstruction instruction, int64_t RegisterValue)
            {
                int FromRegToDependencyInRegConstantsAndToCounter = 1;//(-1) Counter
                int FromRegToNameOfVarInRegConstants = 2;//(-2) NameOfVar
                if (RegConstants.size() > 0)
                {
                    auto it{ std::find(RegConstants.begin(), RegConstants.end(), RegName) };
                    if (it != RegConstants.end());
                    {
                        int i = std::distance(RegConstants.begin(), it);
                       // if (RegConstants[static_cast<std::vector<std::string, std::allocator<std::string>>::size_type>(i) + FromRegToDependencyInRegConstantsAndToCounter]
                       //     != 
                       //     Language_Letters.InstructionPointer + boost::lexical_cast<std::string>(ImmConstantCounter))
                        {
                            std::cout << RegConstants[i - FromRegToNameOfVarInRegConstants] << RegConstants[i - FromRegToDependencyInRegConstantsAndToCounter]
                                << "(" << RegName << ")" << SaveAndUnSaveChooser(instruction, Language_Letters) << "[" << RegConstants[i + FromRegToDependencyInRegConstantsAndToCounter]
                                << "," << Language_Letters.InstructionPointer << boost::lexical_cast<std::string>(ImmConstantCounter) << "]" << " = " << std::hex << RegisterValue << std::endl;
 
                            RegConstants.insert(it + FromRegToDependencyInRegConstantsAndToCounter, std::string(RegConstants[i + FromRegToDependencyInRegConstantsAndToCounter] + "," + 
                                Language_Letters.InstructionPointer + boost::lexical_cast<std::string>(ImmConstantCounter)));
                        }
                    }
                }
            }

            void FormaterAFillerOfRegsARegsConstants(std::string NameOfConstant, ZydisDisassembledInstruction instruction, Language_Letters Language_Letters,
                Constants StructConstants, int64_t RegisterValue, std::string RegName)
            {
                uint64_t Counter = 0;
 
                bool RegIsDecalare = std::binary_search(RegConstants.begin(), RegConstants.end(), RegName);
 
                if (RegIsDecalare == false)
                {
                    std::string temp(Registers::NameChooserByMnemonicForRegisters(NameOfConstant, instruction, StructConstants, RegisterValue) +
                        boost::lexical_cast<std::string>(ImmConstantCounter) + "(" + RegName + ")" + SaveAndUnSaveChooser(instruction, Language_Letters) +
                        Language_Letters.ConstantDependency + boost::lexical_cast<std::string>(ImmConstantCounter) + "]" + " = " + boost::lexical_cast<std::string>(fmt::format("{:x}", RegisterValue)));
 
                    RegConstants.push_back(Registers::NameChooserByMnemonicForRegisters(NameOfConstant, instruction, StructConstants, RegisterValue) +
                        boost::lexical_cast<std::string>(ImmConstantCounter) + "(" + RegName + ")" + SaveAndUnSaveChooser(instruction, Language_Letters) +
                        Language_Letters.ConstantDependency + boost::lexical_cast<std::string>(ImmConstantCounter) + "]");
 
                    RegConstants.push_back(Registers::NameChooserByMnemonicForRegisters(NameOfConstant, instruction, StructConstants, RegisterValue));
                    
                    RegConstants.push_back(boost::lexical_cast<std::string>(ImmConstantCounter));
 
                    RegConstants.push_back(RegName);
 
                    RegConstants.push_back(Language_Letters.InstructionPointer + boost::lexical_cast<std::string>(ImmConstantCounter));
 
 
                    fmt::print("{}\n", temp);
                }
                else
                {
                    RegImmConstantFinderInVectorOfRegConstants(RegName, Language_Letters, instruction, RegisterValue);
 
 
                }
 
                for (; Counter <= ConstantsByTFirstOp.size(); Counter++)
                {
                    auto it = ConstantsByTFirstOp[Counter].end();
                    if (ConstantsByTFirstOp.size() != 0)
                    {
                        auto it{ std::find(ConstantsByTFirstOp[Counter].begin(), ConstantsByTFirstOp[Counter].end(), RegisterValue) };
                    }
                    if (it == ConstantsByTFirstOp[Counter].end())
                    {
                        NameOfConstantsByTFirstOp.push_back(RegName + SaveAndUnSaveChooser(instruction, Language_Letters) +
                            Language_Letters.ConstantDependency + boost::lexical_cast<std::string>(ImmConstantCounter) + "]");
 
 
                        ConstantsByTFirstOp.emplace_back(std::vector<uint64_t>(Counter));
 
                        ConstantsByTFirstOp[Counter].push_back(RegisterValue);
 
                        break;
                    }
                }
            }

auto find_result = vec.begin();
while ( (find_result = find(find_result, vec.end(), find_value)) != vec.end() ){
   // element found
   // do something
}

RegConstants[*it - FromRegToNameOfVarInRegConstants]

RegConstants*(it - FromRegToNameOfVarInRegConstants)