Bug?

It looks like there is a bug here:

else
{
    (11 - 11) - (13 - 13) - inputEncrypted;
}

After simplification, the expression becomes:

else
{
    -inputEncrypted;
}

... which does nothing, as the result is not assigned, the value of inputEncrypted is unchanged. If you wanted to negate the value of the variable, you would have to write like this:

else
{
    inputEncrypted = -inputEncrypted;
}

I don't know if this is your real intention (didn't look at your code close enough). But the original code does absolutely nothing, it's reduced to a statement whose result is not stored anywhere.

Use boolean expressions directly

This can be simplified:

if (success == true && (redo == 'y' || redo == 'Y'))
    keepGoing == true;
else
    keepGoing = false;

To this:

keepGoing = success && (redo == 'y' || redo == 'Y');

Notice how you don't need to write x == true, you can use boolean expressions directly.

Naming

A name like whatToDoFunc is obviously bad. Good function names are extremely important to understand how a program works.

encrypter

int encrypter(int input)
{
    return (input * 2) + 21;
}

Works the same as your function. To get to that I did the following:

• Folding compile time expression.
• Using ternaries.
• Noting that x * 2 + 20 is always even.
• Returning directly with no intermediate variable.

decrypter

decrypter is just the inverse of encrypter so:

int decrypter(int input)
{
    return (input - 21) / 2;
}

Naming

whatToDoFunc and whatToDo are bad names. Use appropriate naming.

Implementation

• Using using namespace std; is bad for ambiguity.
• Don't use std::endl, use '\n'.
• You can simplify some newbie expressions.

You have:

 if (success == true && (redo == 'y' || redo == 'Y'))
                keepGoing == true;
            else
                keepGoing = false;
        }

which can be simplified to:

keepGoing = success && (redo == 'y' || redo == 'Y');

The encrypter function can be simplified to:

int encrypter(int input)
{
    return (input * 2) + 21;
}

The decrypter function can be simplified to:

int decrypter(int inputEncrypted)
{
    int firstresult = inputEncrypted % 2 == 1 ? --inputEncrypted : ((11 - 11) - (13 - 13) - inputEncrypted);
    return ((firstresult - 20) / 2);
}

by using ternaries. Yes, you can do it in one line, but it's preferred to make it more readable.

• getchar() is useful in some cases.

  You have:

  cout << "Enter anykey to exit" << endl;
      cin >> exitCon;
  

  This is not right. Actually, the user needs to press ENTER, not any key. So, replace the cin >> exitCon; with getchar(); (avoid system() functions).

Maybe there is a bug in your program in the encrypt/decrypt functions.

• Signed integer overflow is undefined behavior. Use unsigned int and let it wrap around instead. Otherwise you risk a compiler "optimizing" your code by removing it by proving that it would cause an integer overflow.

• The operation * 2 is not reversible, because you may lose information. The highest bit that you are shifting away should be put to the first bit, making it a bit rotation operation.

  Example: If you were using unsigned char then 200 * 2 = 400 % 256 = 144 and 72 * 2 = 144 and if you want to decrypt a 144 you don't know if it should be 200 or 72. Same applies to integers, just with bigger numbers.

  The solution is to use bit rotation instead which is a bit awkward, but you can check it out here.