Could C++ do this without the #pragma

[Steven T. Hatton]

Stroustrup says this:

http://www.research.att.com/~bs/bs_faq2.html#macro

"So, what's wrong with using macros?"

[...Macros are really bad (I paraphrase - STH)...]

"And yes, I do know that there are things known as macros that doesn't
suffer the problems of C/C++ preprocessor macros. However, I have no
ambitions for improving C++ macros. Instead, I recommend the use of
facilities from the C++ language proper, such as inline functions,
templates, constructors (for initialization) , destructors (for cleanup),
exceptions (for exiting contexts), etc."

The GCC documentation says this:

http://gcc.gnu.org/onlinedocs/gcc-3....++%20Interface
"Declaratio ns and Definitions in One Header"

"C++ object definitions can be quite complex. In principle, your source code
will need two kinds of things for each object that you use across more than
one source file. First, you need an interface specification, describing its
structure with type declarations and function prototypes. Second, you need
the implementation itself. It can be tedious to maintain a separate
interface description in a header file, in parallel to the actual
implementation. It is also dangerous, since separate interface and
implementation definitions may not remain parallel."

[...use our cool #pragmas and don't mess with source/implementation. ..(I
paraphrase - STH) ]

Now, my question is, can the same thing GCC is doing with #pragmas be done
with something internal to C++? I can't see how. I understand that
#pragma is basically a way for the implementation to introduce behavior not
specified in the standard, so there really isn't a direct contradiction to
what Stroustrup id saying. Nonetheless, I would like to be sure there is
no way to accomplish this within the C++ language proper.
--
STH
Hatton's Law: "There is only One inviolable Law"
KDevelop: http://www.kdevelop.org SuSE: http://www.suse.com
Mozilla: http://www.mozilla.org

[Phlip]

Steven T. Hatton wrote:

I've been discussing this on the gcc mailing list, and the responses I've
received have been along the lines of 'the documentation says _that_?'. It
seems I have not correctly understood what the #pragmas are doing, but may
have correctly understood the documentation. I.e., the documentation is
wrong. If I've accomplished anything, it will be to have the #pragma
interface/implementation deprecated, and/or the documentation corrected.

Oh, and I guess I was able to instigate yet another unseemly knock-down,
drag-out fight on c.l.c++, so it was not all for naught. :-)

Try this (from VC++):

#import <mso9.dll>

Hours of fun. For example: Is it a valid implementation-defined
extension? I thought those had to begin with str, __, or #pragma!

--
Phlip