iostream question

This may be a newbie question, but why did people use.

Code:

---

using std::cout;
using std::cin;

---

Couldn't you do the same thing with

Code:

---

#include<iostream>
using namespace std;

---

Is there any advantage of using one over the other?

Namespaces are used to place declarations into a scope defined by the namespace, to hide and logically group the code in such a way as to prevent naming collisions between two different libraries.

By bringing the entire std namespace into scope you run the risk of accidently redefining a function or variable within that namespace. It is also quite wasteful when if you only need to use two or three classes defined within the namespace.

While this is not a big problem with small projects, when you are writing your own larger projects (particularly libraries that may be used by a third party) namespaces are an excellent way of preventing naming clashes and will save you from a lot of grief down the track. The first approach is probably a better one.

Although you could also create another namespace that contains your most commonly used using directives and then include that in your project.

Code:

---

#include <iostream>

namespace my_project
{
    std::cout;
    std::cin;
    std::endl;
}

---

Have this in a header file and include it in your project. Then all you have to do is have a using my_project; directive at the top of your file. Although this probably again isn't useful on small projects.

[edit]
Just to answer your question though, yes you can do the same thing with the second one, however it includes EVERYTHING in the std namespace and is generally considered bad form.

You can also do the following (to only import a few names):

Code:

---

#include <iostream>

using std::cout;
using std::cin;
// .. etc...

int main()
{
  cout << "Hello"; // Okay
  cout << endl; // Not okay, endl is not in the current namespace.
  cout << std::endl; // Okay
  return 0;
}

---

Thanks for the details that is very informative.
So let me recap to make sure I'm reading you correctly.
In my personal head I can create my own namespace.

Code:

---



        #ifndef driver_H
        #define driver_H

        #include <iostream>

      using my_project;

      namespace my_project
      {
          std::cout;
          std::cin;
          std::endl;
      }

        class someclass                     
        {
        public:
        };

        #endif

---

Would this be valid for a header file?

Well, it probably is a bit of overkill and your second option in your first post is probaby the easiest and the first option is probably more correct for a small project. Or as zach pointed out you can use the scope operator to import the names as you need them.

The using directive comes after the declaration of the namespace though.

i.e.

Code:

---

// Include the necassary headers

namespace foo
{
    // Stuff in here you want to have in
    // the foo namespace.
}

using foo;

---

I only really demonstrated that as it can be a good way to reduce the amount of typeing you have to do if your lazy (like me ;) ). Just put all that in its own header then include it in your program whenever you want to use those particular functions.

But, I would do it like this:

Code:

---

#ifndef driver_H
#define driver_H

#include <iostream>

// using my_project; This is not required here

namespace my_project
{
  std::cout;
  std::cin;
  std::endl;
  std::cerr;
    // And everything else that you
    // may use from std
}

#endif

---

You set this file up such that you can use it in any program you write. You would then include this header in your driver/main file and have the using my_project in there just after you have included this file.

But really, it's overkill and to use properly it has to be well thought out. I would suggest just stick with the using directives unless your writing larger sized projects.

now wouldn't it be "using namespace my_project" :

Code:

---

namespace my_project
{
  std::cout;
  std::cin;
  std::endl;
  std::cerr;
    // And everything else that you
    // may use from std
}

---

and

Shouldn't it be:

Code:

---

namespace my_project
{
using  std::cout;
using  std::cin;
using  std::endl;
using  std::cerr;
    // And everything else that you
    // may use from std
}

---

I may be be incorrect...

Just to add what I prefer, unless its a trivial program I don't ever like to use using statements. It starts off as a pain to always write std::cout, std::cin, std::endl, but its not so bad once you get in the habit. That way, you don't have to worry about any of it. Just always put std::.

This is one thing I don't necessarily agree with. People say that programmer's shouldn't include all of the std:: identifiers because it could cause name conflicts. I think, however, that if you're stupid enough to use identifiers that are part of the standard libraries, then you deserve some errors. Just don't name identifiers with the same names as the standard libraries and you don't have a problem including the entire std namespace. Name conflicts should never occur because 1) you should know not to use standard identifiers and 2) if you're identifer is the same then it must do the same thing, but if it does the same thing, then why aren't you just using the standard library version?

That's not the point. The point is namespaces prevent signature conflicts (there are good reasons for reusing function signatures too, you know). I always surround code in a namespace.

- But whatever you do, don't use:

Code:

---


1] using namespace world;
2] namespace world {
3] using namespace world;
}
4] using namespace world;

---

The first line is wrong because it assumes 'world' has already been declared. No good.

The error on line three is in using one's own namespace from within. Also no good.

Line four would be acceptable if this was a major header file, otherwise it's just a waste.

Quote:

---

now wouldn't it be "using namespace my_project" :

---

Mmmm... Yup! Blah, wasn't concentrating at all. ;)