Why does removing using namespace std cause errors in my project? - c++

Question

I have a problem with including header files in C++. As far as I know, it's not a good design to put using namespace std inside header but I got some error when I try to remove it. Here is my code in header file :
#include <iostream>
#include <string>
//using namespace std;
class Messages
{
public:
Messages(string sender, string recipient,int time);
void append();
string to_string();
private:
int time;
string sender;
string recipient;
string text;
};
I did include <string>. However, If I don't use namespace std, all my strings show errors. I do not want to add using namespace std in header file because it's a bad design. So how do I fix it?
Thanks in advance.

Answer 1

Just write std::string everywhere.
#include <iostream>
#include <string>
//using namespace std;
class Messages
{
public:
Messages(std::string sender, std::string recipient,int time);
void append();
std::string to_string();
private:
int time;
std::string sender;
std::string recipient;
std::string text;
};
Just as a rule of thumb: whenever (even in .cpp files) you are using any of the data types or algorithms from the Standard Library, just prefix it with std::. It's brief enough to type, and it will save you a world of pain.
There are some reasons for advanced users to use using declarations at function scope, e.g. when you want to overload a function (e.g. swap) from the Standard Library to work with your own data types (inside their own namespaces). See e.g. this Q&A on how that works.

Answer 2

The class string is declared inside the namespace std. You have three ways of addressing a class that's inside a different namespace:
By always writing <namespace>::<class>
By explicitly declaring that any reference to <class> actually means 1. above: using <namespace>::<class>;.
By declaring that any reference to a <class> that could not be resolved in the current namespace should also be looked up in an additional namespace: using namespace <namespace>;
Those are sorted in descending order of expressiveness. While 1. is perfectly clear wherever written, 3. can require some looking-up and scratching of heads if you are not familiar with the (possible multiple) namespaces used.
These are also sorted in descending order of typing involved, which is why some people (and especially textbooks) opt for 3.
However, you should never use using ... in a header file, because you are not only messing with the namespace resolution inside your header, but also with that of everyone including your header. This results in namespace collisions, strange errors depending on the order of includes and lots of other headaches. Just don't.
And generally speaking, while there is some pro and con involved with options 1. and 2. in implementation files, option 3. is simply offensive to anyone having to work with your source later on.