Is there any way to write nested if conditions shorter? [duplicate]

In this case you could use a switch:

switch (ch) {
case 'A':
case 'B':
case 'C':
    // do something
    break;
case 'D':
case 'E':
case 'F':
    // do something else
    break;
...
}

Note that this won't work as you might expect because of the use of the comma operator:

if  ( ch == 'A', 'B', 'C', ...

This first compares ch to 'A' and then discards the result. Then 'B' is evaluated and discarded, then 'C', and so forth until the last comma expression is evaluated as used as the value of the conditional.

templates!

template<class X, class Y>
bool in(X const& x, Y const& y)
{
    return x == y;
}

template<class X, class Y, class...Rest>
bool in(X const& x, Y const& y, Rest const&...rest)
{
    return in(x, y) or in(x, rest...);
}

int main()
{
    int ch = 6;
    std::cout << in(ch, 1,2,3,4,5,6,7) << std::endl;

    std::string foo = "foo";
    std::cout << in(foo, "bar", "foo", "baz") << std::endl;

    std::cout << in(foo, "bar", "baz") << std::endl;
}

If you need to check a character against an arbitrary set of characters, you could try writing this:

std::set<char> allowed_chars = {'A', 'B', 'C', 'D', 'E', 'G', 'Q', '7', 'z'};
if(allowed_chars.find(ch) != allowed_chars.end()) {
    /*...*/
}

The X-Y answer on the vast majority of modern systems is don't bother.

You can take advantage of the fact that practically every character encoding used today stores the alphabet in one sequentially-ordered contiguous block. A is followed by B, B is followed by C, etc... on to Z. This allows you to do simple math tricks on letters to convert the letter to a number. For example the letter C minus the letter A , 'C' - 'A', is 2, the distance between c and a.

Some character sets, EBCDIC was discussed in the comments above, are not sequential or contiguous for reasons that are out of scope for discussion here. They are rare, but occasionally you will find one. When you do... Well, most of the other answers here provide suitable solutions.

We can use this to make a mapping of letter values to letters with a simple array:

//                    a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p, q,r,s,t,u,v,w,x,y, z
int lettervalues[] = {1,3,3,2,1,4,2,4,1,8,5,1,3,1,1,3,10,1,1,1,1,4,4,8,4,10};

So 'c' - 'a' is 2 and lettervalues[2] will result in 3, the letter value of C.

No if statements or conditional logic required what-so-ever. All the debugging you need to do is proof reading lettervalues to make sure you entered the correct values.

As you study more in C++, you will learn that lettervalues should be static (current translation unit-only access) and const (cannot be changed), possibly constexpr (cannot be changed and fixed at compile time). If you don't know what I'm talking about, don't worry. You'll cover all three later. If not, google them. All are very useful tools.

Using this array could be as simple as

int ComputeWordScore(std::string in)
{
    int score = 0;
    for (char ch: in) // for all characters in string
    {
        score += lettervalues[ch - 'a'];
    }
    return score;
}

But this has two fatal blind spots:

The first is capital letters. Sorry Ayn Rand, but 'A' is not 'a', and 'A'-'a' is not zero. This can be solved by using std::tolower or std::toupper to convert all input to a known case.

int ComputeWordScore(std::string in)
{
    int score = 0;
    for (char ch: in) // for all characters in string
    {
        score += lettervalues[std::tolower(ch) - 'a'];
    }
    return score;
}

The other is input of characters that aren't letters. For example, '1'. 'a' - '1' will result in an array index that is not in the array. This is bad. If you're lucky your program will crash, but anything could happen, including looking as though your program works. Read up on Undefined Behaviour for more.

Fortunately this also has a simple fix: Only compute the score for good input. You can test for valid alphabet characters with std::isalpha.

int ComputeWordScore(std::string in)
{
    int score = 0;
    for (char ch: in) // for all characters in string
    {
        if (std::isalpha(ch))
        {
            score += lettervalues[std::tolower(ch) - 'a'];
        }
        else
        {
            // do something that makes sense here. 
        }
    }
    return score;
}

My something else would be return -1;. -1 is an impossible word score, so anyone who calls ComputeWordScore can test for -1 and reject the user's input. What they do with it is not ComputeWordScore's problem. Generally the stupider you can make a function, the better, and errors should be handled by the closest piece of code that has all the information needed to make a decision. In this case, whatever read in the string would likely be tasked with deciding what to do with bad strings and ComputeWordScore can keep on computing word scores.

Similarly to the C strchr answer, In C++ you can construct a string and check the character against its contents:

#include <string>
...
std::string("ABCDEFGIKZ").find(c) != std::string::npos;

The above will return true for 'F' and 'Z' but false for 'z' or 'O'. This code does not assume contiguous representation of characters.

This works because std::string::find returns std::string::npos when it can't find the character in the string.

^{Live on Coliru}

Edit:

There's another C++ method which doesn't involve dynamic allocation, but does involve an even longer piece of code:

#include <algorithm>
...
char const chars[] = "ABCDEFGIKZ";
return std::find(std::begin(chars), std::end(chars), c) != std::end(chars);

This works similarly to the first code snippet: std::find searches the given range and returns a specific value if the item isn't found. Here, said specific value is the range's end.

^{Live on Coliru}

There is solution to your problem, not in language but in coding practices - Refactoring.

I'm quite sure that readers will find this answer very unorthodox, but - Refactoring can, and is used often to, hide a messy piece of code behind a method call. That method can be cleaned later or it can be left as it is.

You can create the following method:

private bool characterIsValid(char ch) {
    return (ch == 'A' || ch == 'B' || ch == 'C' || ..... );
}

and then this method can be called in a short form as:

if (characterIsValid(ch)) ...

Reuse that method with so many checks and only returning a boolean, anywhere.

Yet another answer on this overly-answered question, which I'm just including for completeness. Between all of the answers here you should find something that works in your application.

So another option is a lookup table:

// On initialization:
bool isAcceptable[256] = { false };
isAcceptable[(unsigned char)'A'] = true;
isAcceptable[(unsigned char)'B'] = true;
isAccetpable[(unsigned char)'C'] = true;

// When you want to check:
char c = ...;
if (isAcceptable[(unsigned char)c]) {
   // it's 'A', 'B', or 'C'.
}

Scoff at the C-style static casts if you must, but they do get the job done. I suppose you could use an std::vector<bool> if arrays keep you up at night. You can also use types besides bool. But you get the idea.

Obviously this becomes cumbersome with e.g. wchar_t, and virtually unusable with multibyte encodings. But for your char example, or for anything that lends itself to a lookup table, it'll do. YMMV.

For this specific case you can use the fact that char is an integer and test for a range:

if(ch >= 'A' && ch <= 'C')
{
    ...
}

But in general this is not possible unfortunately. If you want to compress your code just use a boolean function

if(compare_char(ch))
{
    ...
}

If you want to check for all capital alphabets then you can use if(ch>='A' && ch<='Z').

For all small letters if(ch>='a' && ch<='z').

And for all alphabets input you can use if((ch>='a' && ch<='z') || (ch>='A' && ch<='Z')).

One option is the unordered_set. Put the characters of interest into the set. Then just check the count of the character in question:

#include <iostream>
#include <unordered_set>

using namespace std;

int main() {
  unordered_set<char> characters;
  characters.insert('A');
  characters.insert('B');
  characters.insert('C');
  // ...

  if (characters.count('A')) {
    cout << "found" << endl;
  } else {
    cout << "not found" << endl;
  }

  return 0;
}