Three questions about the head files

ArthurHuang · 06-22-2006, 12:46 AM

1: what's the meaning of explicit? like this:

"explict vector( int theSize =0) : m_CurrentSize( theSize)"

2: Is it correct that include source file at the end of head file? like this:

#ifndef VECTOR_H
#define VECTOR_H

...
..
include "Vector.cpp"
#endif

3:

~vector()
#ifndef WIN32
{
delete[] m_pObjects;}
#else
{
if(m_CurrentSize !=0 )
delete [] m_pObjects;
}
#endif

my question is when and how to set WIN32????

Thanks a lot!

paulsm4 · 06-22-2006, 01:12 AM

Hi -

Quote:

: what's the meaning of explicit? like this:
"explict vector( int theSize =0) : m_CurrentSize( theSize)"

There are three things going on here:

1. He's declaring parameter "theSize", type int, with default value of "0"

2. He's initializing class member "m_currentSize"
... and, the answer to your main question ...

3. "explict" can be anything. It's probably a "#define" in some header file somewhere.

You should be able to "grep" for it wherever this program's header files live.

Here's one example I found on google (from an STL header file):

Code:

# ifdef __STL_NEED_EXPLICIT
#   define explicit
# endif

In this case, "explicit" is a macro that means <<blank space - nothing at all>>

If somebody had source code like you have above (with "explicit" in the declaration), and "__STL_NEED_EXPLICIT" wasn't defined ... then they'd get a compile error.

Quote:

2: Is it correct that include source file at the end of head file? like this:

#ifndef VECTOR_H
#define VECTOR_H

...
..
include "Vector.cpp"
#endif

Syntactically correct? Yes. Wise? It depends... In this case? It's undoubtedly needed to make sure a client who includes the header (which defines the interface) also has access to the template implementation code (in C++, the compiler needs to see the actual source in order to instantiate the template).

Quote:

3:

~vector()
#ifndef WIN32
{
delete[] m_pObjects;}
#else
{
if(m_CurrentSize !=0 )
delete [] m_pObjects;
}
#endif

my question is when and how to set WIN32????

1. "#define WIN32" in the source will work.

2. "-D" from the command line will also work.

3. "/DWIN32" happens automagically when you use Microsoft's Visual Studio (for example) to build a Windows app.

4. If you're *NOT* compiling for Windows, you probably DON'T want to manually "#define" WIN32. If you *ARE* programming on Windows, it's probably happening for you automatically.

Here's one easy way to check - try compiling this:

Code:

#if defined(WIN32)
  #error I guess WIN32 is defined!
#endif

'Hope that helps .. PSM

elluva · 06-22-2006, 03:05 AM

Remember that in this case the inclusion of the cpp source file is done because vector is a template, not a standard C++. If write regular C/C++ don't include your source files in you header files!

Flesym · 06-22-2006, 06:06 AM

Just one correction of paulsm4's explanation:

Quote:

Originally Posted by ArthurHuang

1: what's the meaning of explicit? like this:
"explict vector( int theSize =0) : m_CurrentSize( theSize)"

This is (by default) no definition, but a keyword in C++. It was added to the language to bybass a special behavior of some constructors: A constructor that takes only one argument (maybe followed by others with default-values) also acts as an implicit conversion operator. Example:

Code:

class Foo{
public:
  Foo (int i) : m_i(i) {}
private:
  int m_i;
};

int main(){
  Foo f = 1; //implicit converts '1' to a Foo-object and assignes it to f
}

Such a behavior is (most) often not wanted, that's the gig of explicit. If you modify such constructors with explicit the compiler won't do implicit converstions any more and will throw errors instead:

Code:

class Foo{
public:
  explicit Foo (int i) : m_i(i) {}
private:
  int m_i;
};

int main(){
  Foo f = 1; //error: conversion from `int' to non-scalar type `Foo' requested
}

The correct code would then be:

Code:

//...
int main(){
  Foo f = (Foo)1; //explicit conversion, that's OK!
}

So every such constructor that should not act like an implicit conversion operator, should always be modified with explicit.

paulsm4 · 06-22-2006, 12:38 PM

Thanx, Flesym - you're absolutely correct.

Here's another explanation, from MSVC++:

Quote:

explicit
C++ Specific

This keyword is a declaration specifier that can only be applied to in-class constructor declarations. Constructors declared explicit will not be considered for implicit conversions. For example:

Code:

class X {
public:
   explicit X(int);      //legal
   explicit X(double) {   //legal
      // ...
   }
};

explicit X::X(int) {}      //illegal

An explicit constructor cannot take part in implicit conversions. It can only be used to explicitly construct an object. For example, with the class declared above:

Code:

void f(X) {}
void g(int I) {
   f(i);      // will cause error
}
void h() {
   X x1(1);      // legal

}
The function call f(i) fails because there is no available implicit conversion from int to X.

Note
It is meaningless to apply explicit to constructors with multiple arguments, since such constructors cannot take part in implicit conversions.

Not all C++ compilers necessarily support the "explicit" keyword (it was added in 1998, I believe), hence the need for the "#define explicit" macro in the STL.