একটি স্ট্রিং থেকে নেতৃস্থানীয় এবং পিছনের স্থানগুলি সরিয়ে ফেলা হচ্ছে

Question 1

সি ++ এর স্ট্রিং অবজেক্ট থেকে স্পেসগুলি কীভাবে সরিয়ে ফেলা যায়।
উদাহরণস্বরূপ, নীচের স্ট্রিং অবজেক্ট থেকে কীভাবে নেতৃস্থানীয় এবং অনুসরণযোগ্য স্থানগুলি সরিয়ে ফেলা যায়।

//Original string: "         This is a sample string                    "
//Desired string: "This is a sample string"

স্ট্রিং ক্লাস, যতদূর আমি জানি, নেতৃস্থানীয় এবং পিছনের স্থানগুলি সরানোর কোনও পদ্ধতি সরবরাহ করে না।

সমস্যা যুক্ত করতে, স্ট্রিংয়ের শব্দের মধ্যে অতিরিক্ত স্পেসগুলি প্রক্রিয়াকরণের জন্য এই বিন্যাসটি কীভাবে প্রসারিত করা যায়। উদাহরণ স্বরূপ,

// Original string: "          This       is         a sample   string    " 
// Desired string:  "This is a sample string"

সমাধানে উল্লিখিত স্ট্রিং পদ্ধতিগুলি ব্যবহার করে, আমি দুটি পদক্ষেপে এই অপারেশনগুলি করার কথা ভাবতে পারি।

নেতৃস্থানীয় এবং পিছনের স্থানগুলি সরান।
ব্যবহারের find_first_of, find_last_of, find_first_not_of, find_last_not_of এবং substr , বারবার বলছেন তখন সীমানা বিন্যাস পছন্দসই পেতে।

Question 2

একে ট্রিমিং বলা হয়। আপনি যদি বুস্ট ব্যবহার করতে পারেন আমি এটির পরামর্শ দেব।

অন্যথায়, find_first_not_ofপ্রথম অ-শ্বেতস্পেসের অক্ষরের সূচক পেতে ব্যবহার করুন , তারপরে শূন্যস্থান নয় find_last_not_ofএমন প্রান্ত থেকে সূচকটি পেতে। এইগুলি সহ, ব্যবহার করুনsubstr আশেপাশের কোনও শ্বেতস্পেস ছাড়াই সাব-স্ট্রিংটি ।

আপনার সম্পাদনার প্রতিক্রিয়া হিসাবে, আমি এই শব্দটিটি জানি না তবে আমি "হ্রাস" এর ধারে কিছু অনুমান করব, তাই আমি এটাকে বলেছিলাম। :) (দ্রষ্টব্য, আমি সাদা স্থানকে নমনীয়তার জন্য প্যারামিটার হিসাবে পরিবর্তন করেছি)

#include <iostream>
#include <string>

std::string trim(const std::string& str,
                 const std::string& whitespace = " \t")
{
    const auto strBegin = str.find_first_not_of(whitespace);
    if (strBegin == std::string::npos)
        return ""; // no content

    const auto strEnd = str.find_last_not_of(whitespace);
    const auto strRange = strEnd - strBegin + 1;

    return str.substr(strBegin, strRange);
}

std::string reduce(const std::string& str,
                   const std::string& fill = " ",
                   const std::string& whitespace = " \t")
{
    // trim first
    auto result = trim(str, whitespace);

    // replace sub ranges
    auto beginSpace = result.find_first_of(whitespace);
    while (beginSpace != std::string::npos)
    {
        const auto endSpace = result.find_first_not_of(whitespace, beginSpace);
        const auto range = endSpace - beginSpace;

        result.replace(beginSpace, range, fill);

        const auto newStart = beginSpace + fill.length();
        beginSpace = result.find_first_of(whitespace, newStart);
    }

    return result;
}

int main(void)
{
    const std::string foo = "    too much\t   \tspace\t\t\t  ";
    const std::string bar = "one\ntwo";

    std::cout << "[" << trim(foo) << "]" << std::endl;
    std::cout << "[" << reduce(foo) << "]" << std::endl;
    std::cout << "[" << reduce(foo, "-") << "]" << std::endl;

    std::cout << "[" << trim(bar) << "]" << std::endl;
}

ফলাফল:

[too much               space]  
[too much space]  
[too-much-space]  
[one  
two]

Question 3

একটি লাইনে স্টাডি :: স্ট্রিং থেকে শীর্ষস্থানীয়, চলমান এবং অতিরিক্ত স্থানগুলি সরানো সহজ

value = std::regex_replace(value, std::regex("^ +| +$|( ) +"), "$1");

কেবল নেতৃস্থানীয় স্থানগুলি সরিয়ে ফেলা হচ্ছে

value.erase(value.begin(), std::find_if(value.begin(), value.end(), std::bind1st(std::not_equal_to<char>(), ' ')));

বা

value = std::regex_replace(value, std::regex("^ +"), "");

কেবল অনুসরণকারী জায়গাগুলি সরানো

value.erase(std::find_if(value.rbegin(), value.rend(), std::bind1st(std::not_equal_to<char>(), ' ')).base(), value.end());

বা

value = std::regex_replace(value, std::regex(" +$"), "");

শুধুমাত্র অতিরিক্ত স্থান অপসারণ

value = regex_replace(value, std::regex(" +"), " ");

Question 4

আমি বর্তমানে এই ফাংশনগুলি ব্যবহার করছি:

// trim from left
inline std::string& ltrim(std::string& s, const char* t = " \t\n\r\f\v")
{
    s.erase(0, s.find_first_not_of(t));
    return s;
}

// trim from right
inline std::string& rtrim(std::string& s, const char* t = " \t\n\r\f\v")
{
    s.erase(s.find_last_not_of(t) + 1);
    return s;
}

// trim from left & right
inline std::string& trim(std::string& s, const char* t = " \t\n\r\f\v")
{
    return ltrim(rtrim(s, t), t);
}

// copying versions

inline std::string ltrim_copy(std::string s, const char* t = " \t\n\r\f\v")
{
    return ltrim(s, t);
}

inline std::string rtrim_copy(std::string s, const char* t = " \t\n\r\f\v")
{
    return rtrim(s, t);
}

inline std::string trim_copy(std::string s, const char* t = " \t\n\r\f\v")
{
    return trim(s, t);
}

Question 5

স্ট্রিং ট্রিম অ্যালগরিদম বুস্ট করুন

#include <boost/algorithm/string/trim.hpp>

[...]

std::string msg = "   some text  with spaces  ";
boost::algorithm::trim(msg);

Question 6

শীর্ষস্থানীয় এবং অনুসরণযোগ্য স্থানগুলি সরিয়ে ফেলার জন্য এটি আমার সমাধান ...

std::string stripString = "  Plamen     ";
while(!stripString.empty() && std::isspace(*stripString.begin()))
    stripString.erase(stripString.begin());

while(!stripString.empty() && std::isspace(*stripString.rbegin()))
    stripString.erase(stripString.length()-1);

ফলাফল "প্লেনেন"

Question 7

আপনি এটি কীভাবে করতে পারেন তা এখানে:

std::string & trim(std::string & str)
{
   return ltrim(rtrim(str));
}

এবং সহায়ক ফাংশনগুলি হিসাবে প্রয়োগ করা হয়:

std::string & ltrim(std::string & str)
{
  auto it2 =  std::find_if( str.begin() , str.end() , [](char ch){ return !std::isspace<char>(ch , std::locale::classic() ) ; } );
  str.erase( str.begin() , it2);
  return str;   
}

std::string & rtrim(std::string & str)
{
  auto it1 =  std::find_if( str.rbegin() , str.rend() , [](char ch){ return !std::isspace<char>(ch , std::locale::classic() ) ; } );
  str.erase( it1.base() , str.end() );
  return str;   
}

এবং একবার আপনি এই সমস্ত জায়গায় হয়ে গেলে আপনি এটি আরও লিখতে পারেন:

std::string trim_copy(std::string const & str)
{
   auto s = str;
   return ltrim(rtrim(s));
}

এটা চেষ্টা কর

Question 8

জোন-হ্যানসনকে বুস্ট ব্যবহারের পরামর্শের পরে (কেবলমাত্র ট্রেলিং এবং মুলতুবি থাকা স্থানগুলি সরিয়ে দেয়) ট্রিমের শীর্ষস্থানীয় এবং অনুসরণযোগ্য স্থানগুলির উদাহরণ:

#include <boost/algorithm/string/trim.hpp>

std::string str = "   t e s t    ";

boost::algorithm::trim ( str );

ফলাফল স্বরূপ "t e s t"

এছাড়াও আছে

trim_left ফলাফল স্বরূপ "t e s t "
trim_right ফলাফল স্বরূপ " t e s t"

Question 9

/// strip a string, remove leading and trailing spaces
void strip(const string& in, string& out)
{
    string::const_iterator b = in.begin(), e = in.end();

    // skipping leading spaces
    while (isSpace(*b)){
        ++b;
    }

    if (b != e){
        // skipping trailing spaces
        while (isSpace(*(e-1))){
            --e;
        }
    }

    out.assign(b, e);
}

উপরের কোডে, ইস্পেস () ফাংশনটি একটি বুলিয়ান ফাংশন যা একটি চরিত্র একটি সাদা স্থান কিনা তা জানায়, আপনি আপনার প্রয়োজনগুলি প্রতিফলিত করতে এই ফাংশনটি বাস্তবায়ন করতে পারেন, বা চাইলে "ctype.h" থেকে স্পেস () স্পেস কল করুন you ।

Question 10

শীর্ষস্থানীয় এবং পিছনে স্থানগুলি ছাঁটাই করার উদাহরণ

std::string aString("    This is a string to be trimmed   ");
auto start = aString.find_first_not_of(' ');
auto end = aString.find_last_not_of(' ');
std::string trimmedString;
trimmedString = aString.substr(start, (end - start) + 1);

বা

trimmedSring = aString.substr(aString.find_first_not_of(' '), (aString.find_last_not_of(' ') - aString.find_first_not_of(' ')) + 1);

Question 11

স্ট্যান্ডার্ড লাইব্রেরিটি ব্যবহার করার অনেক সুবিধা রয়েছে তবে ব্যতিক্রমের কারণ হতে পারে এমন কয়েকটি বিশেষ ক্ষেত্রে সম্পর্কে অবশ্যই সচেতন হওয়া উচিত। উদাহরণস্বরূপ, উত্তরের কোনওটিই সেই ক্ষেত্রেটি কাভার করে না যেখানে সি ++ স্ট্রিংয়ের কিছু ইউনিকোড অক্ষর রয়েছে। এই ক্ষেত্রে, আপনি যদি স্পেসটি স্পেসটি ব্যবহার করেন তবে একটি ব্যতিক্রম ছুঁড়ে দেওয়া হবে।

আমি স্ট্রিংগুলি এবং অন্যান্য কিছু ক্রিয়াকলাপগুলি ছাঁটাই করার জন্য নিম্নলিখিত কোডটি ব্যবহার করছি যা কার্যকর হতে পারে। এই কোডের প্রধান সুবিধাগুলি হ'ল: এটি সত্যই দ্রুত (আমার আগে যে কোনও কোড পরীক্ষা করা হয়েছে তার চেয়ে দ্রুত) এটি কেবলমাত্র স্ট্যান্ডার্ড লাইব্রেরি ব্যবহার করে এবং এটি কখনও ব্যতিক্রম ঘটায় না:

#include <string>
#include <algorithm>
#include <functional>
#include <locale>
#include <iostream>

typedef unsigned char BYTE;

std::string strTrim(std::string s, char option = 0)
{
    // convert all whitespace characters to a standard space
    std::replace_if(s.begin(), s.end(), (std::function<int(BYTE)>)::isspace, ' ');

    // remove leading and trailing spaces
    size_t f = s.find_first_not_of(' ');
    if (f == std::string::npos) return "";
    s = s.substr(f, s.find_last_not_of(' ') - f + 1);

    // remove consecutive spaces
    s = std::string(s.begin(), std::unique(s.begin(), s.end(),
        [](BYTE l, BYTE r){ return l == ' ' && r == ' '; }));

    switch (option)
    {
    case 'l':  // convert to lowercase
        std::transform(s.begin(), s.end(), s.begin(), ::tolower);
        return s;
    case 'U':  // convert to uppercase
        std::transform(s.begin(), s.end(), s.begin(), ::toupper);
        return s;
    case 'n':  // remove all spaces
        s.erase(std::remove(s.begin(), s.end(), ' '), s.end());
        return s;
    default: // just trim
        return s;
    }
}

Question 12

এটি সবচেয়ে সহজ হতে পারে।

আপনি উভয় পক্ষ থেকে সাদা স্থান অনুসন্ধান করতে string::findএবং string::rfindস্ট্রিং হ্রাস করতে ব্যবহার করতে পারেন ।

void TrimWord(std::string& word)
{
    if (word.empty()) return;

    // Trim spaces from left side
    while (word.find(" ") == 0)
    {
        word.erase(0, 1);
    }

    // Trim spaces from right side
    size_t len = word.size();
    while (word.rfind(" ") == --len)
    {
        word.erase(len, len + 1);
    }
}

Question 13

আমি এটি পরীক্ষা করেছি, সব কাজ করে। সুতরাং এই পদ্ধতির প্রক্রিয়া ইনপুট ব্যবহারকারীকে কিছু লিখতে বলবে it এটি এমন একটি স্ট্রিং ফিরিয়ে দেবে যা অভ্যন্তরীণভাবে কোনও অতিরিক্ত স্থান নেই, না শুরুতে বা শেষের দিকে অতিরিক্ত স্পেস রয়েছে। আশাকরি এটা সাহায্য করবে. (এটিকে বোঝার পক্ষে সহজ করার জন্য মন্তব্য করার একটি গাদাও রাখুন)।

আপনি নীচে মূল () এ এটি কীভাবে প্রয়োগ করবেন তা দেখতে পাবেন

#include <string>
#include <iostream>

string processInput() {
  char inputChar[256];
  string output = "";
  int outputLength = 0;
  bool space = false;
  // user inputs a string.. well a char array
  cin.getline(inputChar,256);
  output = inputChar;
       string outputToLower = "";
  // put characters to lower and reduce spaces
  for(int i = 0; i < output.length(); i++){
    // if it's caps put it to lowercase
    output[i] = tolower(output[i]);
    // make sure we do not include tabs or line returns or weird symbol for null entry array thingy
    if (output[i] != '\t' && output[i] != '\n' && output[i] != 'Ì') {
      if (space) {
        // if the previous space was a space but this one is not, then space now is false and add char
        if (output[i] != ' ') {
          space = false;
          // add the char
          outputToLower+=output[i];
        }
      } else {
        // if space is false, make it true if the char is a space
        if (output[i] == ' ') {
          space = true;
        }
        // add the char
        outputToLower+=output[i];
      }
    }
  }
  // trim leading and tailing space
  string trimmedOutput = "";
  for(int i = 0; i < outputToLower.length(); i++){
    // if it's the last character and it's not a space, then add it
    // if it's the first character and it's not a space, then add it
    // if it's not the first or the last then add it
    if (i == outputToLower.length() - 1 && outputToLower[i] != ' ' || 
      i == 0 && outputToLower[i] != ' ' || 
      i > 0 && i < outputToLower.length() - 1) {
      trimmedOutput += outputToLower[i];
    } 
  }
  // return
  output = trimmedOutput;
  return output;
}

int main() {
  cout << "Username: ";
  string userName = processInput();
  cout << "\nModified Input = " << userName << endl;
}

Question 14

জটিল কেন?

std::string removeSpaces(std::string x){
    if(x[0] == ' ') { x.erase(0, 1); return removeSpaces(x); }
    if(x[x.length() - 1] == ' ') { x.erase(x.length() - 1, x.length()); return removeSpaces(x); }
    else return x;
}

এটি কাজ করে এমনকি বুস্ট ব্যর্থ হয় না, কোনও রেইজেক্স না, কোনও অদ্ভুত জিনিস বা লাইব্রেরি ছিল না।

সম্পাদনা: এমএম এর মন্তব্যের জন্য ঠিক করুন।

Question 15

সি ++ 17 প্রবর্তিত std::basic_string_view, একটি শ্রেণিবদ্ধ টেমপ্লেট যা চর-জাতীয় বস্তুর ধ্রুবক ধারাবাহিক অনুক্রমকে বোঝায়, স্ট্রিংয়ের দৃশ্য। এর সাথে খুব অনুরূপ ইন্টারফেস থাকা ছাড়াও std::basic_stringএর দুটি অতিরিক্ত ফাংশন রয়েছে: remove_prefix()যা তার সূচনাটি সামনে এগিয়ে নিয়ে যাওয়াটি সঙ্কুচিত করে; এবং remove_suffix(), যা এর প্রান্তটি পিছনে সরিয়ে দিয়ে সঙ্কুচিত হয়। এগুলি নেতৃস্থানীয় এবং অনুসরণযোগ্য স্থান ট্রিম করতে ব্যবহার করা যেতে পারে:

#include <string_view>
#include <string>

std::string_view ltrim(std::string_view str)
{
    const auto pos(str.find_first_not_of(" \t"));
    str.remove_prefix(pos);
    return str;
}

std::string_view rtrim(std::string_view str)
{
    const auto pos(str.find_last_not_of(" \t"));
    str.remove_suffix(str.length() - pos - 1);
    return str;
}

std::string_view trim(std::string_view str)
{
    str = ltrim(str);
    str = rtrim(str);
    return str;
}

int main()
{
    std::string str = "   hello world   ";
    auto sv1{ ltrim(str) };  // "hello world   "
    auto sv2{ rtrim(str) };  // "   hello world"
    auto sv3{ trim(str) };   // "hello world"

    //If you want, you can create std::string objects from std::string_view objects
    auto s1{ sv1 };
    auto s2{ sv2 };
    auto s3{ sv3 };
}

দ্রষ্টব্য: এটি std::string_viewএকটি মালিকানাবিহীন রেফারেন্স, সুতরাং মূল স্ট্রিংটি এখনও অবধি বিদ্যমান it's

Question 16

    char *str = (char*) malloc(50 * sizeof(char));
    strcpy(str, "    some random string (<50 chars)  ");

    while(*str == ' ' || *str == '\t' || *str == '\n')
            str++;

    int len = strlen(str);

    while(len >= 0 && 
            (str[len - 1] == ' ' || str[len - 1] == '\t' || *str == '\n')
    {
            *(str + len - 1) = '\0';
            len--;
    }

    printf(":%s:\n", str);

Question 17

void removeSpaces(string& str)
{
    /* remove multiple spaces */
    int k=0;
    for (int j=0; j<str.size(); ++j)
    {
            if ( (str[j] != ' ') || (str[j] == ' ' && str[j+1] != ' ' ))
            {
                    str [k] = str [j];
                    ++k;
            }

    }
    str.resize(k);

    /* remove space at the end */   
    if (str [k-1] == ' ')
            str.erase(str.end()-1);
    /* remove space at the begin */
    if (str [0] == ' ')
            str.erase(str.begin());
}

Question 18

string trim(const string & sStr)
{
    int nSize = sStr.size();
    int nSPos = 0, nEPos = 1, i;
    for(i = 0; i< nSize; ++i) {
        if( !isspace( sStr[i] ) ) {
            nSPos = i ;
            break;
        }
    }
    for(i = nSize -1 ; i >= 0 ; --i) {
        if( !isspace( sStr[i] ) ) {
            nEPos = i;
            break;
        }
    }
    return string(sStr, nSPos, nEPos - nSPos + 1);
}

Question 19

শীর্ষস্থানীয় এবং পিছনের স্থানগুলির জন্য, কীভাবে:

string string_trim(const string& in) {

    stringstream ss;
    string out;
    ss << in;
    ss >> out;
    return out;

}

বা একটি বাক্যের জন্য:

string trim_words(const string& sentence) {
    stringstream ss;
    ss << sentence;
    string s;
    string out;

    while(ss >> s) {

        out+=(s+' ');
    }
    return out.substr(0, out.length()-1);
}

Question 20

পরিষ্কার এবং পরিচ্ছন্ন

 void trimLeftTrailingSpaces(string &input) {
        input.erase(input.begin(), find_if(input.begin(), input.end(), [](int ch) {
            return !isspace(ch);
        }));
    }

    void trimRightTrailingSpaces(string &input) {
        input.erase(find_if(input.rbegin(), input.rend(), [](int ch) {
            return !isspace(ch);
        }).base(), input.end());
    }

Question 21

না boost, না regex, কেবল stringগ্রন্থাগার। এটা খুব সহজ।

string trim(const string s) { // removes whitespace characters from beginnig and end of string s
    const int l = (int)s.length();
    int a=0, b=l-1;
    char c;
    while(a<l && ((c=s.at(a))==' '||c=='\t'||c=='\n'||c=='\v'||c=='\f'||c=='\r'||c=='\0')) a++;
    while(b>a && ((c=s.at(b))==' '||c=='\t'||c=='\n'||c=='\v'||c=='\f'||c=='\r'||c=='\0')) b--;
    return s.substr(a, 1+b-a);
}

Question 22

সমস্যা যুক্ত করতে, স্ট্রিংয়ের শব্দের মধ্যে অতিরিক্ত স্পেসগুলি প্রক্রিয়াকরণের জন্য এই বিন্যাসটি কীভাবে প্রসারিত করা যায়।

প্রকৃতপক্ষে, একাধিক শীর্ষস্থানীয় এবং অনুসরণযোগ্য সাদা-স্পেস অক্ষরের জন্য অ্যাকাউন্টিংয়ের চেয়ে এটি সরল কেস। আপনাকে যা করতে হবে তা হ'ল সম্পূর্ণ স্ট্রিং থেকে সদৃশ সংলগ্ন সাদা-স্পেস অক্ষরগুলি সরিয়ে ফেলা।

সংলগ্ন সাদা স্থানের জন্য সহজবোধ্যটি হ'ল:

auto by_space = [](unsigned char a, unsigned char b) {
    return std::isspace(a) and std::isspace(b);
};

এবং তারপরে আপনি সেই সদৃশ সংলগ্ন সাদা-স্পেস অক্ষরগুলি std::uniqueএবং মুছে ফেলুন আইডিয়ামটি থেকে মুক্তি পেতে পারেন :

// s = "       This       is       a sample   string     "  
s.erase(std::unique(std::begin(s), std::end(s), by_space), 
        std::end(s));
// s = " This is a sample string "

এটি সম্ভাব্যভাবে সামনের এবং / অথবা পিছনে একটি অতিরিক্ত সাদা-স্পেস অক্ষর রেখে দেয়। এটি বেশ সহজেই সরানো যেতে পারে:

if (std::size(s) && std::isspace(s.back()))
    s.pop_back();

if (std::size(s) && std::isspace(s.front()))
    s.erase(0, 1);

এখানে একটি ডেমো রয়েছে ।

Question 23

এই সমস্যার জন্য আমার সমাধানটি কোনও এসটিএল পদ্ধতি ব্যবহার না করে কেবল সি ++ স্ট্রিংয়ের নিজস্ব পদ্ধতিগুলি নিম্নলিখিত হিসাবে রয়েছে ：

void processString(string &s) {
    if ( s.empty() ) return;

    //delete leading and trailing spaces of the input string
    int notSpaceStartPos = 0, notSpaceEndPos = s.length() - 1;
    while ( s[notSpaceStartPos] == ' ' ) ++notSpaceStartPos;
    while ( s[notSpaceEndPos] == ' ' ) --notSpaceEndPos;
    if ( notSpaceStartPos > notSpaceEndPos ) { s = ""; return; }
    s = s.substr(notSpaceStartPos, notSpaceEndPos - notSpaceStartPos + 1);

    //reduce multiple spaces between two words to a single space 
    string temp;
    for ( int i = 0; i < s.length(); i++ ) {
        if ( i > 0 && s[i] == ' ' && s[i-1] == ' ' ) continue;
        temp.push_back(s[i]);
    }
    s = temp;
}

আমি একটি স্ট্রিংয়ে একটি লেটকোড সমস্যা বিপরীত শব্দগুলি পাস করার জন্য এই পদ্ধতিটি ব্যবহার করেছি

Question 24

void TrimWhitespaces(std::wstring& str)
{
    if (str.empty())
        return;

    const std::wstring& whitespace = L" \t";
    std::wstring::size_type strBegin = str.find_first_not_of(whitespace);
    std::wstring::size_type strEnd = str.find_last_not_of(whitespace);

    if (strBegin != std::wstring::npos || strEnd != std::wstring::npos)
    {
        strBegin == std::wstring::npos ? 0 : strBegin;
        strEnd == std::wstring::npos ? str.size() : 0;

        const auto strRange = strEnd - strBegin + 1;
        str.substr(strBegin, strRange).swap(str);
    }
    else if (str[0] == ' ' || str[0] == '\t')   // handles non-empty spaces-only or tabs-only
    {
        str = L"";
    }
}

void TrimWhitespacesTest()
{
    std::wstring EmptyStr = L"";
    std::wstring SpacesOnlyStr = L"    ";
    std::wstring TabsOnlyStr = L"           ";
    std::wstring RightSpacesStr = L"12345     ";
    std::wstring LeftSpacesStr = L"     12345";
    std::wstring NoSpacesStr = L"12345";

    TrimWhitespaces(EmptyStr);
    TrimWhitespaces(SpacesOnlyStr);
    TrimWhitespaces(TabsOnlyStr);
    TrimWhitespaces(RightSpacesStr);
    TrimWhitespaces(LeftSpacesStr);
    TrimWhitespaces(NoSpacesStr);

    assert(EmptyStr == L"");
    assert(SpacesOnlyStr == L"");
    assert(TabsOnlyStr == L"");
    assert(RightSpacesStr == L"12345");
    assert(LeftSpacesStr == L"12345");
    assert(NoSpacesStr == L"12345");
}

Question 25

মুছা মুছা-মুছিয়া মুছা সম্পর্কে কী ?

std::string s("...");
s.erase( std::remove(s.begin(), s.end(), ' '), s.end() );

দুঃখিত আমি অনেক দেরিতে দেখেছি যে আপনি সমস্ত সাদা স্থান সরাতে চান না ।