Create a program that will take user input, reverse it, and then check if it is a palindrome
I think you have a classic case of not knowing the standard.
What you are writing is generally already available via either a normal constructor or a standard algorithm. In a few cases I would have just implemented a minor wrapper class that could be used by these facilities.
Lets have a look at a few and see how you could have utilized the standard:
  std::vector &lt;char&gt; stringToVec(std::string inputString) {
    std::vector &lt;char&gt; letters;
    for (int a = 0; a &lt; inputString.size(); a++) {
      letters.push_back(inputString.at(a));
    }
    return letters;
  }

The first thing to point out is that you are passing the parameter by value std::string inputString. This means you are copying the parameter into the function. This can be expensive (especially with strings and vectors). Also you are not mutating them so much easier to pass by const reference.
  std::vector &lt;char&gt; stringToVec(std::string const&amp; inputString) {
                                    //       ^^^^^^^
    std::vector &lt;char&gt; letters;
    for (int a = 0; a &lt; inputString.size(); a++) {
      letters.push_back(inputString.at(a));
    }
    return letters;
  }

This means you can read the original parameter but can not modify it:
The method at() is a bounds checking access operator. If you know that your index is going to be in range then prefer to use operator[]. In the case above you always know that a is going to be in the correct range because you actively check to make sure it is in the correct range a &lt; inputString.size().
  std::vector &lt;char&gt; stringToVec(std::string const&amp; inputString) {
    std::vector &lt;char&gt; letters;
    for (int a = 0; a &lt; inputString.size(); a++) {
      letters.push_back(inputString[a]);  // Don't need to valid range
                                          // When your loop is already
                                          // guaranteeing the range.
    }
    return letters;
  }

Most algorithms we use tend to use iterators, so get used to using them. So I would re-write the above loop in terms of iterators:
  std::vector &lt;char&gt; stringToVec(std::string const&amp; inputString) {
    std::vector &lt;char&gt; letters;
    for (auto loop = std::begin(inputString), loop != std::end(inputString); ++loop) {
      letters.push_back(*loop);
    }
    return letters;
  }

This is such a common pattern that in C++11 they introduced the range based for expression. Basically this is a for() loop that works with an object that can accept std::begin() and std::end() being called on it. It is basically syntactic sugar to make the above loop simpler to write:
  std::vector &lt;char&gt; stringToVec(std::string const&amp; inputString) {
    std::vector &lt;char&gt; letters;
    for (auto letter: inputString) {
      letters.push_back(letter);
    }
    return letters;
  }

But if we look at std::vector&lt;&gt; we see that it also has a constructor that accepts two iterators so you can simply use this to construct the vector:
  std::vector &lt;char&gt; stringToVec(std::string const&amp; inputString) {
    std::vector &lt;char&gt; letters(std::begin(inputString), std::end(inputString));
    return letters;
  }

Or more simply:
  std::vector &lt;char&gt; stringToVec(std::string const&amp; inputString) {
    return std::vector&lt;char&gt;(std::begin(inputString), std::end(inputString));
  }

We can go through the same processes in reverse of the next function vecToString().
std::string vecToString(std::vector&lt;char&gt; const&amp; inputVec) {
  return std::string(std::begin(inputVec), std::end(inputVec));
}

Just as a little style niggle. The seporation of the template type from the class looks strange.
std::vector &lt;char&gt;
         ^^^^^     That space just looks strange.

Lets move to cleaning the string:
std::string cleanString(std::string inputString) {
  std::locale loc;
  for (std::string::size_type i = 0; i &lt; inputString.length(); i++) {
    inputString[i] = std::tolower(inputString[i], loc);
  }
  for (std::string::size_type i = 0; i &lt; inputString.length(); i++) {
    if (inputString[i] == ' ') {
      inputString.erase(i, 1);
    }
  }
  return inputString;
}

Again looking at your loops. I would convert them to using iterators and then range based for. But these are also classic algorithms supported by the standard.
Converting to lower case:
  for (std::string::size_type i = 0; i &lt; inputString.length(); i++) {
    inputString[i] = std::tolower(inputString[i], loc);
  }

This is a standard transform:
 std::transform(std::begin(inputString), std::end(inputString), // Source
                std::begin(inputString),                        // Destination (can be source) as long as it it is already large enough.
                [&amp;loc](unsigned char c){return std::tolower(c, loc)}
               );

Removing a particular character:
  for (std::string::size_type i = 0; i &lt; inputString.length(); i++) {
    if (inputString[i] == ' ') {
      inputString.erase(i, 1);
    }
  }

This is a standard remove/erase
 auto newEnd = std::remove(std::begin(inputString), std::end(inputString), ' ');
 inputString.erase(newEnd, std::end(inputString));

This is so common we usually write it as a single line:
 inputString.erase(std::remove(std::begin(inputString), std::end(inputString), ' '), std::end(inputString));

Commonly referred to as the erase/remove pattern.
Simple tests can sometime be replaced by the trinary operator. BUT be careful if overused or used in bad places this technique can make the code work (so be careful of using this). But in this instance I think it makes the code easier to read:
if (cleanString(originalString) == cleanString(reversedString)) {
  return &quot;Yes&quot;;
}
return &quot;No&quot;;

You can simplify this to:
return (cleanString(originalString) == cleanString(reversedString))
    ? &quot;Yes&quot;
    : &quot;No&quot;;

Reversing a container:
std::vector &lt;char&gt; reverseVec(std::vector &lt;char&gt; inputVec) {
  std::vector &lt;char&gt; reversedReturn;
  for (int a = inputVec.size() - 1; a &gt;= 0; a--) {
    reversedReturn.push_back(inputVec.at(a));
  }
  return reversedReturn;
}

Like above you can improve your code by using iterators.
std::vector &lt;char&gt; reverseVec(std::vector&lt;char&gt; const&amp; inputVec) {
  std::vector &lt;char&gt; reversedReturn;
  for (auto loop = std::rbegin(inputVec), loop != std::rend(inputVec); ++loop) {
    reversedReturn.push_back(*loop);
  }
  return reversedReturn;
}

The rbegin() and rend() provide `reverse iterators. They go in the opposite direction to your standard iterator but are basically the same.
We can expand this (like above to just constructing the container with the iterators).
std::vector &lt;char&gt; reverseVec(std::vector&lt;char&gt; const&amp; inputVec) {
  return std::vector&lt;char&gt;(std::rbegin(inputVec), std::rend(inputVec));
}

There is also standard algorithm std::reverse() that reverse a container in place.
Using the above:
int main()
{
  std::cout &lt;&lt; &quot;Enter the string you would like reversed: &quot;;

  std::string userInput;
  std::getline(std::cin, userInput, '\n');

  auto newEnd = std::remove(std::begin(userInput), std::end(userInput), ' ');
  std::erase(newEnd, std::end(userInput));

  std::transform(std::begin(userInput),  std::end(userInput),
                 std::begin(userInput),
                 [](unsigned char* c){std::tolower(c);});


  std::string reversedInput(std::rbegin(userInput), std::rend(userInput));

  std::cout &lt;&lt; &quot;Reversed: &quot; &lt;&lt; reversedInput &lt;&lt; &quot;\n&quot;
            &lt;&lt; &quot;Palindrome: &quot;
            &lt;&lt; ((userInput == reversedInput) ? &quot;Yes&quot; : &quot;No&quot;)
            &lt;&lt; &quot;\n&quot;;
}