C++ (Cpp) TSTRING::replace Examples

Programming Language: C++ (Cpp)

Class/Type: TSTRING

Method/Function: replace

Examples at hotexamples.com: 2

TString Replace is a function in the C++ programming language that allows users to replace a certain substring of characters in a string with a new substring. This function is commonly used in text processing and manipulation.

Example 1: Replacing a word in a sentence

#include 

void replaceWord(TString& sentence, TString old_word, TString new_word){
    sentence.ReplaceAll(old_word, new_word);
}

int main(){
    TString sentence = "The quick brown fox jumps over the lazy dog";
    TString old_word = "fox";
    TString new_word = "cat";
    replaceWord(sentence, old_word, new_word);
    std::cout << sentence << std::endl;
    return 0;
}

The above code replaces the word "fox" in the sentence with "cat" using the TString Replace function.

Example 2: Replacing a character in a string

#include 

void replaceChar(TString& word, char old_char, char new_char){
    TString old_string = old_char;
    TString new_string = new_char;
    word.ReplaceAll(old_string, new_string);
}

int main(){
    TString word = "hello";
    char old_char = 'l';
    char new_char = 'x';
    replaceChar(word, old_char, new_char);
    std::cout << word << std::endl;
    return 0;
}

The above code replaces the character "l" in the string "hello" with "x" using the TString Replace function. The TString Replace function is part of the ROOT package library, which is a set of C++ libraries used for data analysis and visualization. The ROOT package library is commonly used in fields such as physics, bioinformatics, and finance.

C++ (Cpp) TSTRING::replace - 2 examples found. These are the top rated real world C++ (Cpp) examples of TSTRING::replace extracted from open source projects. You can rate examples to help us improve the quality of examples.

Frequently Used Methods

Show Hide

c_str(30)

append(15)

empty(14)

end(11)

begin(10)

resize(8)

size(6)

length(5)

substr(5)

data(5)

compare(5)

find(4)

erase(3)

find_last_of(2)

replace(2)

assign(1)

find_first_not_of(1)

rfind(1)

Example #1

Show file

File: NodeFunction.cpp Project: AsamQi/node-sqlite3

	TSTRING Replace( const TSTRING& orignStr, const TSTRING& oldStr, const vector<TSTRING>&vc )
	{
		size_t pos = 0; 
		TSTRING tempStr = orignStr; 
		TSTRING::size_type newStrLen; 
		TSTRING::size_type oldStrLen = oldStr.length();
		int i=0;

		while(true) 
		{ 
			pos = tempStr.find(oldStr, pos); 
			if (pos == TSTRING::npos) break; 
			TSTRING s=vc.at(i);
			s = _T("\'")+s +_T("\'");
			newStrLen= s.length(); 

			tempStr.replace(pos, oldStrLen, s);         
			pos += newStrLen;
			i++;

		} 

		return tempStr; 

	}

Example #2

Show file

File: genreparseinfo.cpp Project: brc0x1/tripwire-open-source

bool cGenreParseInfo::DoVarSubstitution( TSTRING &rval ) //throw( eParserHelper )
{
    cDebug d("cConfigFile::DoVarSubst()");
    d.TraceDebug("ORIG: %s\n", rval.c_str());

    // walk through string
    //      look for $(
    //          find matching )
    //          pick out subset
    //          look up in symbol table
    //          substitute subset
    //      continue iterating

    // step through string
    // iterate to (slen-1), because we are looking for a two-character sentinel "$("
    bool fEscaping = false;
    for (TSTRING::size_type i = 0; i < rval.size(); i++) 
    {
        TCHAR c = rval[i];

        // is it the "$(" sentinel? (an escaped '$' is not a variable)
        if (c == '$' && ! fEscaping ) 
        {
            c = rval[i+1];
            if (c == '(') 
            {
                // ooh, wow!  it's a variable!  find the end
                bool found = false;
                TSTRING::size_type j;

                for (j = i+1; j < rval.size(); j++) 
                {
                    if (rval[j] == ')') 
                    {
                        found = true;
                        break;
                    }
                }

                // did we find it?
                if (!found) 
                {
                    // TODO: throw error
                    return false;
                }

                // otherwise, cut out the variable name
                TSTRING::size_type begin = i + 2;
                TSTRING::size_type size = j - i - 2;
                TSTRING varname;
                varname = rval.substr(begin, size);

                d.TraceDebug("symbol = %s\n", varname.c_str());

                // look up in symbol table
                TSTRING varvalue;
                if ( ! LookupVariable( varname, varvalue ) ) 
                    throw eParserUseUndefVar( varname );

                // replace varname with varvalue
                rval.replace(begin-2, size+3, varvalue);

                d.TraceDebug("POST: %s\n", rval.c_str());

                // no no no
                // we should exit function, and get called again


                // update counters
                //      we should bump the cursor over by the length of the 
                //          varvalue (minus one, to compensate for post-increment of index)
                i += varvalue.size() - 1;
                goto nextchar;
            }
        }
        else if (c == '\\')
        {
            fEscaping = ! fEscaping;
        }
        else
        {
            fEscaping = false;
        }
nextchar:
        ;
    }



    d.TraceDebug("DONE: %s\n", rval.c_str());

    // switch around
    return true;
}