Question about using namespace std

Question about using namespace std

Post by Schizoid M » Thu, 24 Aug 2006 05:50:43


Hi,

I'm a novice whose just about migrating to C++ after cutting my teeth on
C for a few years.

To start with I'm using Microsoft's out-of-the-box Visual C++ Express
Edition compiler and I had a couple of questions:

1. If I am using namespace std, is there a specific reason for me to
place std:: before all the manipulators - cout, endl, etc? I've noticed
that without the std:: prefix, all the methods work as expected.

2. I've been skimming Deitel's How to Program in C++ and noticed
something very strange. In the chapter on functions, the author's code
contains the function method AFTER the main() method, even though the
main() method calls the function. This would throw a compile error in C,
so is this valid syntax in C++?

3. Another question about bridging C and C++: I do know that an implicit
conversion from void* to double* is completely legal in C, but (so I'm
told) illegal in C++. Is there a reason for the latter?

Thanks in advance,
Schiz
 
 
 

Question about using namespace std

Post by Alf P. Ste » Thu, 24 Aug 2006 06:15:27

* Schizoid Man:

Namespace qualification (writing "std::") is required unless you have a
"using" declaration or directive.

See the FAQ item "Should I use using namespace std in my code?"
currently at <url:
http://www.yqcomputer.com/ ++-faq-lite/coding-standards.html#faq-27.5>.



AFAIK in C you /can/ use an undeclared function, and that's part of the
reason why it's not a good idea to cast the result of malloc in C. In
C++ you /can't/ use a so far undeclared free-standing function. So if
you're talking about free-standing functions, then the assertion in your
last sentence has it exactly backwards.

However, it seems you're talking about a class with a member function
'main'. Generally a class that "does" is a Bad Idea (TM), except for
functor and functoid classes. See the FAQ item "] What the heck is a
functionoid, and why would I use one?" currently at <url:
http://www.yqcomputer.com/ ++-faq-lite/pointers-to-members.html#faq-33.10>.
Another exception: sometimes a class includes a "doer" function or
functions for purposes of automated unit testing. But in general, steer
away from thinking of a class as "doing" something: that's a function.

Anyway, when you write a class with inline function bodies like

struct S
{
void foo() { bar(); }
void bar() { say( "Heh" ); }
};

it's as if you wrote (it's a shorthand notation for)

struct S
{
void foo();
void bar();
};

inline void S::foo() { bar(); }

inline void S::bar() { say( "Heh" ); }

and here you can see that S::foo doesn't actually call a function S::bar
that hasn't yet been declared: it's just the shorthand notation for
defining inline member functions, where you place the function body in
the class definition, that makes it seem that way.



C++ is more type-oriented than C, attempting to have somewhat stronger
static type checking.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

 
 
 

Question about using namespace std

Post by Mark » Thu, 24 Aug 2006 06:42:56


I haven't seen the book, but perhaps the author has declared the
functions called in main somewhere earlier. From the sounds of it, I
would guess that they're declared in an included header file.

This is legal:



// foo.h

void foo(); // no definition, just a declaration




// foo.cpp

#include "foo.h"

int main ()
{
foo();
}

void foo()
{
// do stuff
}
 
 
 

Question about using namespace std

Post by Jim Langst » Fri, 25 Aug 2006 08:06:41


No, there is no need to use std:: before manipulators if you are using
namespace std. But you can, as you have found, use them anyway.

It is my personal opionion, and many others, never to use using namespace
std as it brings everything into the unnamed namespace, defeating the
purpose of namespaces in the first place. A better way is not to use using
at all but prefix with std:: always, or you can bring in the specific things
you want.

using std::cout;
using std::endl;
etc..


I'm guessing this is for methods in a class?


C++ is much more strict on types than C. Makes it better so that we don't
make as many stupid mistakes.