C++ 如何在C++；？

例如，我让一个用户输入一个电话号码

cout << "Enter phone number: ";
INPUT: (555) 555-5555
cin >> phone;

cout>电话；

我想从字符串中删除“（“，”）和“-”字符。我已经查看了字符串remove、find和replace函数，但是我只看到它们是根据位置进行操作的

---

是否有一个字符串函数可以用来传递字符“”（“例如，让它删除字符串中的所有实例？

是的，可以使用isdigit（）函数检查数字：）

给你：

#include <iostream>
#include <cctype>
#include <string.h>

using namespace std;

int main(){

  char *str = "(555) 555-5555";
  int len = strlen(str);

  for (int i=0; i<len; i++){
      if (isdigit(*(str+i))){
        cout << *(str+i);
      }
  }

  cout << endl;


return 0;   
}

#包括
#包括
#包括
使用名称空间std；
int main（）{
char*str=“（555）555-5555”；
int len=strlen（str）；
对于（inti=0；i
stringstr（“（555）555-5555”）；
字符[]=“（）-”；
for（无符号整数i=0；icout恐怕std:：string没有这样的成员，但是您可以很容易地编写这种函数。
这可能不是最快的解决方案，但这就足够了：

std::string RemoveChars(const std::string& source, const std::string& chars) {
   std::string result="";
   for (unsigned int i=0; i<source.length(); i++) {
      bool foundany=false;
      for (unsigned int j=0; j<chars.length() && !foundany; j++) {
         foundany=(source[i]==chars[j]);
      }
      if (!foundany) {
         result+=source[i];
      }
   }
   return result;
}

将导致

99999876543.87

我想删除“（“，”）和“-”
字符串中的字符

您可以使用
std:：remove_if（）
算法仅删除指定的字符：

#include <iostream>
#include <algorithm>
#include <string>

bool IsParenthesesOrDash(char c)
{
    switch(c)
    {
    case '(':
    case ')':
    case '-':
        return true;
    default:
        return false;
    }
}

int main()
{
    std::string str("(555) 555-5555");
    str.erase(std::remove_if(str.begin(), str.end(), &IsParenthesesOrDash), str.end());
    std::cout << str << std::endl; // Expected output: 555 5555555
}

您可以使用
“（）-”
字符串指定要删除的字符。在上面的示例中，我添加了一个空格，以便删除空格以及括号和破折号。
如果您可以访问支持可变模板的编译器，则可以使用以下方法：

#include <iostream>
#include <string>
#include <algorithm>

template<char ... CharacterList>
inline bool check_characters(char c) {
    char match_characters[sizeof...(CharacterList)] = { CharacterList... };
    for(int i = 0; i < sizeof...(CharacterList); ++i) {
        if(c == match_characters[i]) {
            return true;
        }
    }
    return false;
}

template<char ... CharacterList>
inline void strip_characters(std::string & str) {
    str.erase(std::remove_if(str.begin(), str.end(), &check_characters<CharacterList...>), str.end());
}

int main()
{
    std::string str("(555) 555-5555");
    strip_characters< '(',')','-' >(str);
    std::cout << str << std::endl;
}

#包括
#包括
#包括
模板
内联布尔校验字符（字符c）{
字符匹配\字符[sizeof…（CharacterList）]={CharacterList…}；
对于（int i=0；i（str）；
std:：coutremove_if（）已被提及。但是，对于C++0x，您可以使用lambda为其指定谓词

下面是一个例子，有3种不同的过滤方法。当您使用常量或不想修改原始值时，也会包含函数的“复制”版本

#include <iostream>
#include <string>
#include <algorithm>
#include <cctype>
using namespace std;

string& remove_chars(string& s, const string& chars) {
    s.erase(remove_if(s.begin(), s.end(), [&chars](const char& c) {
        return chars.find(c) != string::npos;
    }), s.end());
    return s;
}
string remove_chars_copy(string s, const string& chars) {
    return remove_chars(s, chars);
}

string& remove_nondigit(string& s) {
    s.erase(remove_if(s.begin(), s.end(), [](const char& c) {
        return !isdigit(c);
    }), s.end());
    return s;
}
string remove_nondigit_copy(string s) {
    return remove_nondigit(s);
}

string& remove_chars_if_not(string& s, const string& allowed) {
    s.erase(remove_if(s.begin(), s.end(), [&allowed](const char& c) {
        return allowed.find(c) == string::npos;
    }), s.end());
    return s;
}
string remove_chars_if_not_copy(string s, const string& allowed) {
    return remove_chars_if_not(s, allowed);
}

int main() {
    const string test1("(555) 555-5555");
    string test2(test1);
    string test3(test1);
    string test4(test1);
    cout << remove_chars_copy(test1, "()- ") << endl;
    cout << remove_chars(test2, "()- ") << endl;
    cout << remove_nondigit_copy(test1) << endl;
    cout << remove_nondigit(test3) << endl;
    cout << remove_chars_if_not_copy(test1, "0123456789") << endl;
    cout << remove_chars_if_not(test4, "0123456789") << endl;
}

#包括
#包括
#包括
#包括
使用名称空间std；
字符串和删除字符（字符串和字符、常量字符串和字符）{
s、 擦除（删除_if（s.begin（）、s.end（）、[&chars]（常量字符和c）{
return chars.find（c）！=string:：npos；
})，s.end（））；
返回s；
}
字符串删除\u字符\u复制（字符串、常量字符串和字符）{
返回移除字符（个字符，个字符）；
}
字符串和删除\u非数字（字符串和s）{
s、 擦除（删除_if（s.begin（）、s.end（）、[]（常量字符和c）{
返回！isdigit（c）；
})，s.end（））；
返回s；
}
字符串删除\u非数字\u副本（字符串s）{
返回移除非数字；
}
字符串和删除字符（如果不允许）（字符串和字符、常量字符串和允许）{
s、 擦除（如果（s.begin（）、s.end（）、[&允许]（const char&c）则删除{
允许返回。find（c）=string:：npos；
})，s.end（））；
返回s；
}
字符串删除\u字符\u如果\u不复制（字符串s、常量字符串&允许）{
如果不允许，则返回删除字符；
}
int main（）{
常量字符串test1（“（555）555-5555”）；
字符串test2（test1）；
字符串test3（test1）；
字符串test4（test1）；
cout还有另一种选择：

template<typename T>
void Remove( std::basic_string<T> & Str, const T * CharsToRemove )
{
    std::basic_string<T>::size_type pos = 0;
    while (( pos = Str.find_first_of( CharsToRemove, pos )) != std::basic_string<T>::npos )
    {
        Str.erase( pos, 1 ); 
    }
}

std::string a ("(555) 555-5555");
Remove( a, "()-");

模板
void Remove（std:：basic_string&Str，const T*CharsToRemove）
{
std:：basic_string:：size_type pos=0；
while（（pos=Str.find_first_of（CharsToRemove，pos））！=std:：basic_string:：npos）
{
Str.erase（位置1）；
}
}
std：：字符串a（“（555）555-5555”）；
删除（a）（“（）-”）；

与std:：string和std:：wstring一起使用我是新手，但是上面的一些答案非常复杂，所以这里有一个替代方案

注意：只要0-9是连续的（根据标准，它们应该是连续的），就应该过滤掉除数字和“”以外的所有其他字符。知道0-9应该是连续的，并且字符实际上是int，我们可以执行以下操作

编辑：我没有注意到海报也需要空格，所以我修改了它

#include <cstdio>
#include <cstring>

void numfilter(char * buff, const char * string)
{
  do
  { // According to standard, 0-9 should be contiguous in system int value.
    if ( (*string >= '0' && *string <= '9') || *string == ' ')
      *buff++ = *string;
  } while ( *++string );
  *buff++ = '\0'; // Null terminate
}

int main()
{
  const char *string = "(555) 555-5555";
  char buff[ strlen(string) + 1 ];

  numfilter(buff, string);
  printf("%s\n", buff);

return 0;
}

#包括
#包括
void numfilter（char*buff，const char*string）
{
做
{//根据标准，0-9在系统int值中应该是连续的。
如果（（*string>='0'&&*string，对于任何感兴趣的人来说，这里有一个不同的解决方案。它使用c++11中的新for范围

string str("(555) 555-5555");
string str2="";

for (const auto c: str){

    if(!ispunct(c)){

        str2.push_back(c);
    }
}

str = str2;
//output: 555 5555555
cout<<str<<endl;

stringstr（“（555）555-5555”）；
字符串str2=“”；
用于（常数自动c:str）{
如果（！ispunt（c））{
str2.推回（c）；
}
}
str=str2；
//输出：5555555
库特
注意：对于那些喜欢更简洁、更易于阅读的lambda编码风格的人，您可能需要编写
ptr\u-fun
而不是简单的
ptr\u-fun

此示例从宽字符串中删除所有非字母数字字符和空白字符。您可以将其与任何其他辅助函数混合使用，以删除外观复杂的基于字符的测试

（我不确定这些函数如何处理CJK语言，所以请轻点走。）

//无聊的C循环：'for（int i=0；i使用std:：wstring和wchar\u t（需要Unicode头）：

/#包括
标准：无线电话（L“（555）555-5555”）；

…接下来是一个奇特的静态范围初始值设定项；无需以完全相同的方式设置badChars2。这太过分了；比任何其他方法都更具学术性：

const wchar_t *tmp = L"()-"; 
const std::set<wchar_t> badChars2(tmp,tmp + sizeof(tmp)-1);

const wchar_t*tmp=L“（）-”；
const std:：set badChars2（tmp，tmp+sizeof（tmp）-1）；

简单、简洁的lambda：

在lambda捕获列表中使用电话
使用
template<typename T>
void Remove( std::basic_string<T> & Str, const T * CharsToRemove )
{
    std::basic_string<T>::size_type pos = 0;
    while (( pos = Str.find_first_of( CharsToRemove, pos )) != std::basic_string<T>::npos )
    {
        Str.erase( pos, 1 ); 
    }
}

std::string a ("(555) 555-5555");
Remove( a, "()-");

#include <cstdio>
#include <cstring>

void numfilter(char * buff, const char * string)
{
  do
  { // According to standard, 0-9 should be contiguous in system int value.
    if ( (*string >= '0' && *string <= '9') || *string == ' ')
      *buff++ = *string;
  } while ( *++string );
  *buff++ = '\0'; // Null terminate
}

int main()
{
  const char *string = "(555) 555-5555";
  char buff[ strlen(string) + 1 ];

  numfilter(buff, string);
  printf("%s\n", buff);

return 0;
}

#include <cstdio>
#include <cstring>

void cfilter(char * buff, const char * string, const char * toks)
{
  const char * tmp;  // So we can keep toks pointer addr.
  do
  {
    tmp = toks;
    *buff++ = *string; // Assume it's correct and place it.
    do                 // I can't think of a faster way.
    {
      if (*string == *tmp)
      {
        buff--;  // Not correct, pull back and move on.
        break;
      }
    }while (*++tmp);
  }while (*++string);

  *buff++ = '\0';  // Null terminate
}

int main()
{
  char * string = "(555) 555-5555";
  char * toks = "()-";
  char buff[ strlen(string) + 1 ];

  cfilter(buff, string, toks);
  printf("%s\n", buff);

  return 0;
}

string str("(555) 555-5555");
string str2="";

for (const auto c: str){

    if(!ispunct(c)){

        str2.push_back(c);
    }
}

str = str2;
//output: 555 5555555
cout<<str<<endl;

using namespace std;


// c++03
string s = "(555) 555-5555";
s.erase(remove_if(s.begin(), s.end(), not1(ptr_fun(::isdigit))), s.end());

// c++11
s.erase(remove_if(s.begin(), s.end(), ptr_fun(::ispunct)), s.end());

    // Boring C loops: 'for(int i=0;i<str.size();i++)' 
    // Boring C++ eqivalent: 'for(iterator iter=c.begin; iter != c.end; ++iter)'

TSTRING label = _T("1.   Replen & Move  RPMV");
TSTRING newLabel = label;
set<TCHAR> badChars; // Use ispunct, isalpha, isdigit, et.al. (lambda version, with capture list parameter(s) example; handiest thing since sliced bread)
for_each(label.begin(), label.end(), [&badChars](TCHAR n){
    if (!isalpha(n) && !isdigit(n))
        badChars.insert(n);
});

for_each(badChars.begin(), badChars.end(), [&newLabel](TCHAR n){
    newLabel.erase(std::remove(newLabel.begin(), newLabel.end(), n), newLabel.end());
});

//#include <tchar.h>
std::wstring phone(L"(555) 555-5555");

const wchar_t *tmp = L"()-"; 
const std::set<wchar_t> badChars2(tmp,tmp + sizeof(tmp)-1);

for_each(badChars2.begin(), badChars2.end(), [&phone](wchar_t n){
     phone.erase(std::remove(phone.begin(), phone.end(), n), phone.end());
});
wcout << phone << endl;

#include <cassert>

#include <boost/range/algorithm/remove_if.hpp>
#include <boost/algorithm/string/classification.hpp>

int main() {
    std::string str = "a_bc0_d";
    str.erase(boost::remove_if(str, boost::is_any_of("_0")), str.end());
    assert((str == "abcd"));
}

string str("(555) 555-5555"), clean;
for (char c : str)
    if (c >= 48 and c <= 57)
        clean.push_back(c);

std::erase(phone, '('); 

std::erase_if(phone, [](char x) { 
                        return x == '(' or x == ')' or x == '-'; 
                     });