如何在if语句中比较多个字符串

我想变量theString的类型是std::string。否则至少这个比较

theString == "Seven"

没有意义，

if语句中的条件

if (theString == "Seven" || "seven" || "7")

等于

if ( ( theString == "Seven" ) || ( "seven" ) || ( "7" ) )

并始终产生true，因为字符串文字"seven"的地址至少不等于零。因此，此子表达( "seven" )规定整个表达式将等于true。

你应该写

if (theString == "Seven" || theString == "seven" || theString == "7")

，但首先将字符串转换为上或下情况会更好。

例如

#include <algorithm>
#include <string>
#include <cstring>
//...
std::transform(theString.begin(), theString.end(), theString.begin(),
    [](char c) { return std::toupper((unsigned char)c);  });
if (theString == "SEVEN" || theString == "7")
{
    theInt = 7;
    cout << "You chose: " << theInt << endl;
}
else if ( theString == "SIX" || theString == "6" )
{
    theInt = 6;
    cout << "You chose: " << theInt << endl;
}

使用std::set和C 11您可以用与您的语法相似的语法进行一个。

检查以下内容：

#include <iostream>
#include <string>
#include <set>
int main()
{
  
  if( (std::set<std::string>{"Seven", "seven", "7"}).count("seven") )
  {
      std::cout << "foon";
  }
  
  std::string theString("6");
  
  if( (std::set<std::string>{"Six", "six", "6"}).count(theString) )
  {
      std::cout << "barn";
  }
}

注意：从C 20您可以使用contains而不是count

您无法将变量与C 中的多个值进行比较。您应该这样做：

if (theString == "Seven" || theString == "seven" || theString ==  "7")
 {
   theInt = 7;
   cout << "You chose: " << theInt << endl;
 }
else if (theString == "Six" || theString == "six" || theString == "6")
 {
   theInt = 6;
   cout << "You chose: " << theInt << endl;
 }

有时，数据可以比代码更好。

std::map<std::string, int> values;
values["Seven"]=7;
values["seven"]=7;
values["7"]=7;
values["Six"]=6;
values["six"]=6;
values["6"]=6;
std::string input;
std::cin >> input;
std::cout << values[input];

正如Vlad所指出的那样，您可能会更好地转换为小写。这个答案只是您的代码直接转换为数据。请注意，此答案将使用缺少字符串的默认值为0；您的代码遗漏了这样的默认。

这是识别实现过程中发现的派生要求的经典示例。我建议您考虑编写支持它的功能。

从

if (theString == "Seven" || "seven" || "7")
{
//....

(这是无效的C ，因为IF条件始终是正确的(

更改为

if (0 == compare(theString, "Seven", "seven", "7")
{
//....

并声明并实施

// return 0 when theString matches at least one patX
// else return -1
int compare(const std::string& theString, 
            const char* pat0,  // no default, must provide
            const char* pat1 = nullptr, 
            const char* pat2 = nullptr, 
            const char* pat3 = nullptr, 
            const char* pat4 = nullptr
            /* add as many patX as you desire */)
{
    if (0 == theString.compare(pat0)) return 0; // found a match
    //
    // ignore nullptr patterns 
    if (nullptr != pat1) && (0 == theString.compare(pat1)) {
       return(0);
    }
    if(nullptr != pat2) && (0 == theString.compare(pat2)) {
       return(0);
    }
    // ...
    // when get to end with no match
    return (-1); // indicate no match to any of patterns
}

我实际上更喜欢以下内容。以上类似于strstr((，其中使用std :: string

int compare(const std::string& theString, // what you are given
            const std::string& patterns)  // concatenated list of search patterns
{
//.. 
}

这个您调用为

if (0 == compare(theString, "Seven seven SEVEN 7") 
{
// 

实现必须嘲笑空间划定的模式..但这并不困难，可以轻松地在循环中实现，因此您希望测试多少比较没有限制。

您何时应该考虑创建一个新功能以支持新的派生rerquirement？

当我可以识别3个或更多用途时，我的做法是创建新功能。祝你好运。

找到了我几年前写的一些代码，修复了它，添加了演示...

代码编译并似乎运行，但很少进行测试。

• 我创建了最小包装 - 一个虚拟命名空间(DTB-用于D ___的工具箱(和Dumy类(T471_T-测试471(

DTB :: T471_T提供私人方法供您审核。

• size_t comparare(const std :: string s，std :: string模式(

• size_t grep(const std :: string pfn，const std :: string模式， STD :: Ostream＆amp;an_ostream = std :: cout(

  - 使用compare((

• size_t cpuinfoget((

  - 使用grep

  - " wc＆lt;/proc/cpuinfo"(ubuntu上的一个''''文件(报告了我的2台核心机器上的54行，更多的内核，更多的行

• size_t corecountget((

  - 使用grep((

  - 创建nulldev以抑制GREP正常输出

#include <chrono>
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <cassert>
// 'compressed' chrono access --------------vvvvvvv
typedef std::chrono::high_resolution_clock  HRClk_t; // std-chrono-hi-res-clk
typedef HRClk_t::time_point                 Time_t;  // std-chrono-hi-res-clk-time-point
typedef std::chrono::microseconds           US_t;    // std-chrono-microseconds
using   namespace std::chrono_literals;   // support suffixes like 100ms
// examples:
//
//   Time_t start_us = HRClk_t::now();
//
//   auto  duration_us = std::chrono::duration_cast<US_t>(HRClk_t::now() - start_us);
//   auto     count_us = duration_us.count();
//   or
//   std::cout << "  complete " << duration_us.count() << " us" << std::endl;
namespace dtb
{
   class T471_t
   {
      const std::string dashLine = ("  --------------------------------------------------------------");
   public:
      T471_t() = default;
      ~T471_t() = default;
      int exec()
         {
            std::cout << "n  cpuinfoGet()n" << dashLine << std::endl;
            (void)cpuinfoGet(); // uses grep which uses compare
            std::cout << dashLine << std::endl;
            // count of lines which contain "processor" in linux file "/proc/cpuinfo"
            std::cout << "nn  " << coreCountGet()
                      << " cores on this system. (coreCountGet())nn" << std::endl;
            return(0);
         }

   private: // methods
      // returns std::string::npos when none of the patterns found,
      // else returns index of earliest found patterns of space delimited substr in
      size_t compare (const std::string& s,
                      std::string        patterns) // pass by value
         {
            size_t    found = std::string::npos;
            size_t patCount = 0;
            std::stringstream ssPat(patterns + ' '); // load patterns into ram based stringstream
            //                            ^^^^^ -- getline() can cause eof() in this
            const char delim = ' '; // see getline()
            do
            {
               if(0 == patterns.size()) break; // no patterns to search for, kick out
               if(0 == s.size())     break; // no string in which to search, kick out
               do {
                  std::string pat;
                  (void)std::getline(ssPat, pat, delim); // extract 1 space delimited pattern
                  if(false == ssPat.good())
                  {
                     if(ssPat.eof()) break; // quitely exit, a normal op
                     // let user know of patten problem
                     std::cerr << "n  err pattern extract: " << patterns
                               << "  (" << patCount << ')' << std::endl;
                     break;
                  }
                  patCount += 1;
                  //trimLeadingWhiteSpace(patterns);  // tbr
                  //trimTrailingWhiteSpace(patterns); // tbr
                  if(0 == patterns.size()) break; // no more patterns
                  // search s for pat
                  found = s.find(pat);
                  if(found != std::string::npos) break; // one of the patterns found in s
               } while(1); // repeat until 1 found or all patterns tried
            }while(0);
            return(found);
         } // size_t compare (const std::string& s, std::string patterns)

      size_t grep(const std::string pfn,
                  const std::string patterns, // concatenated list of search patterns
                  std::ostream&     an_ostream = std::cout) // redirectable
         {
            size_t   foundCount = 0;
            an_ostream << "  grep (" << pfn << ", [" << patterns
                       << "] )" << std::endl;
            do
            {
               std::ifstream infile(pfn);
               if(!infile.is_open())
               {
                  an_ostream << pfn << " not found.n" << std::endl; // tbr - std::cerr?
                  break; // skip over file op's (no close needed)
               }
               do
               {
                  if(infile.eof()) break;  // file empty?
                  std::string lineIn;
                  (void)getline(infile, lineIn); // default delimiter is n
                  if (0 == lineIn.size()) continue; // empty line?
                  size_t found = compare(lineIn, patterns); // any of patterns in lineIn?
                  if(std::string::npos != found) // found at least one pattern
                  {
                     an_ostream << "  " << lineIn << std::endl; // found it, print it
                     foundCount += 1;
                  }
                  // else no pattern found - continue until eof of inFil
               } while(1);
               infile.close();
            }while(0);
            return(foundCount);
         } // size_t grep(const std::string pfn, const std::string patterns, std::ostream& an_ostream = std::cout)
      //                                space delimited list of ---^^^^^^^^

      size_t cpuinfoGet()
         {
            size_t count = grep("/proc/cpuinfo",  // pfn
                                "bogomips model name processor"); // patterns to search for
            std::cout << "n  info lines: " << count << std::endl;
            return(count);
         } // size_t cpuinfoGet(void)

      size_t coreCountGet()
         {
            // create a no-ouptput output
            std::ofstream nullDev; // and do not open
            nullDev.setstate(std::ios_base::badbit); // set error, ignore errors, do not close
            size_t retVal = grep(std::string("/proc/cpuinfo"),
                                 std::string("processor"),  // line count of "processor" is core count
                                 nullDev); // nullDev -- no output
            return(retVal);
         } // size_t coreCountGet()(void)
   }; // class T471_t
} // namespace dtb

int main(int /*argc*/, char** /*argv[]*/)
{
  Time_t start_us = HRClk_t::now();
  int retVal = -1;
  {
     dtb::T471_t  t471;
     retVal = t471.exec();
  }
  auto  duration_us = std::chrono::duration_cast<US_t>(HRClk_t::now() - start_us);
  std::cout << "  FINI   " << duration_us.count() << " us" << std::endl;
  return(retVal);
}

输出：

cpuinfoGet()
--------------------------------------------------------------
grep (/proc/cpuinfo, [bogomips model name processor] )
processor   : 0
model       : 75
model name  : AMD Athlon(tm) 64 X2 Dual Core Processor 5000+
bogomips    : 4809.67
processor   : 1
model       : 75
model name  : AMD Athlon(tm) 64 X2 Dual Core Processor 5000+
bogomips    : 4809.67
info lines: 8
--------------------------------------------------------------

 2 cores on this system. (coreCountGet())

 FINI   829 us

避免代码中的硬编码字符串。此示例是可扩展的。您可以在一个地方轻松地添加字符串及其相应的值。

typedef struct
{
    const char *oneString;
    int value;
} THESTRINGS;
THESTRINGS theStrings[]
{
    "seven", 7,
    "six", 6
};
#define STRINGCOUNT (sizeof(theStrings) / sizeof(theStrings[0]))
int main()
{
    int i;
    const char* theString = "SIX";
    for (i = 0; i < STRINGCOUNT; i++)
    {
        if (_stricmp(theString, theStrings[i].oneString) == 0)              // Case does not matter with _stricmp()
        {
            printf("Found %s and its value %d", theString, theStrings[i].value);
            break;
        }
    }
    return 0; // Prints "Found SIX and its value 6"
}