Dividing a namespace into declaration and elaboration parts

[PaperPilot]

I have this namespace which works fine if I put everything in the header file:

namespace util
{
 
    float getFloat(char* buf, int from);
    bool  getBool(char* buf, int from);
    short getShort(char* buf, int from);
 
 
float getFloat(char* buf, int from)
{
    buf+=from;
 
    float tempVal;
    memcpy(&tempVal, buf , sizeof(float));
 
    return tempVal;
}
 
bool getBool(char* buf, int from)
{
    buf+=from;
 
    bool tempVal;
    memcpy(&tempVal, buf , sizeof(bool));
 
    return tempVal;
}
 
short getShort(char* buf, int from)
{
    buf+=from;
 
    bool tempVal;
    memcpy(&tempVal, buf , sizeof(bool));
 
    return tempVal;
}
 
} // namespace util
 

I don't feel comfortable doing it this way and would rather put the elaboration code in a separate file. Nothing I tried has worked.

Can the namespace be divided up, or must I leave it alone?

Thanks in advance.

[AdrianH]

I don't feel comfortable doing it this way and would rather put the elaboration code in a separate file. Nothing I tried has worked.

Can the namespace be divided up, or must I leave it alone?

Thanks in advance.

There is good reason why you shouldn't feel comfortable. This will not work if you include the header file more than once in your source code as it will generate multiple instances of the functions which will then conflict with each other.

Yes the namespace can be divided up. It can be declared as many times as you want. Every time you declare a namespace with the same name, it will add whatever you put within the namespace block into the namespace that you specify.

I.e.
Header file:

namespace util
{
 
    float getFloat(char* buf, int from);
    bool  getBool(char* buf, int from);
    short getShort(char* buf, int from);
}
 

Source file:

namespace util
{
 
float getFloat(char* buf, int from)
{
    buf+=from;
 
    float tempVal;
    memcpy(&tempVal, buf , sizeof(float));
 
    return tempVal;
}
 
bool getBool(char* buf, int from)
{
    buf+=from;
 
    bool tempVal;
    memcpy(&tempVal, buf , sizeof(bool));
 
    return tempVal;
}
 
short getShort(char* buf, int from)
{
    buf+=from;
 
    bool tempVal;
    memcpy(&tempVal, buf , sizeof(bool));
 
    return tempVal;
}
 
} // namespace util
 

Alternatively, you can specify it in absolute terms like so:
Source file:

float util::getFloat(char* buf, int from)
{
    buf+=from;
 
    float tempVal;
    memcpy(&tempVal, buf , sizeof(float));
 
    return tempVal;
}
 
bool util::getBool(char* buf, int from)
{
    buf+=from;
 
    bool tempVal;
    memcpy(&tempVal, buf , sizeof(bool));
 
    return tempVal;
}
 
short util::getShort(char* buf, int from)
{
    buf+=from;
 
    bool tempVal;
    memcpy(&tempVal, buf , sizeof(bool));
 
    return tempVal;
}
 

Hope this helps,


Adrian

[PaperPilot]

There is good reason why you shouldn't feel comfortable. This will not work if you include the header file more than once in your source code as it will generate multiple instances of the functions which will then conflict with each other.

Yes the namespace can be divided up. It can be declared as many times as you want. Every time you declare a namespace with the same name, it will add whatever you put within the namespace block into the namespace that you specify.

Adrian

Adrain:

I tried both methods you suggested, putting elaboration code in a .cpp file. It compiled fine, but failed to link. There must be some step I am leaving out.

[AdrianH]

Adrain:

I tried both methods you suggested, putting elaboration code in a .cpp file. It compiled fine, but failed to link. There must be some step I am leaving out.

Please specify your compiler and what version it is. Also indicate how you are compiling this.


Adrian

[PaperPilot]

Please specify your compiler and what version it is. Also indicate how you are compiling this.


Adrian

I am using the gnu complier for the PPC604 which creates a partially linked object. Final linking happens during load. The IDE is Eclipse 3.1.2 using Wind River Systems Workbench 2.5b plugins. The target system uses vxWorks 6.3.

[AdrianH]

I am using the gnu complier for the PPC604 which creates a partially linked object. Final linking happens during load. The IDE is Eclipse 3.1.2 using Wind River Systems Workbench 2.5b plugins. The target system uses vxWorks 6.3.

VxWorks, eh? I used to make fun of it and say it didn't work two jobs ago. Well, they had a few issues with their header files not being up to date (constness was one that really bugged me). And that Tornado environment! ARGH! To be fair, I was using the old crap because of my employer and was slowly started to move towards the new stuff only because WindRiver issued end of life statments. :) Yeah, the good ol' days... 6 months ago. :D Anyway, enough reminicing.

I tried it under Cygwin gnu g++ 3.4.4 compiler using Eclipse 3.2.1 with a managed makefile project (so it does all the dependency checking for me). I separated it into two files, main.cpp and main.h. What follows is the contents of both:

main.h

#ifndef MAIN_H_
#define MAIN_H_
namespace util
{
 
    float getFloat(char* buf, int from);
    bool  getBool(char* buf, int from);
    short getShort(char* buf, int from);
}
#endif /*MAIN_H_*/
 

main.cpp

#include "main.h"
#include <memory.h>
#if 0
namespace util
{
    short getShort(char* buf, int from)
    {
        buf+=from;
 
        bool tempVal;
        memcpy(&tempVal, buf , sizeof(bool));
 
        return tempVal;
    }
} // namespace util
#else
short util::getShort(char* buf, int from)
{
    buf+=from;
 
    bool tempVal;
    memcpy(&tempVal, buf , sizeof(bool));
 
    return tempVal;
}
#endif
 
int main()
{
    char buffer[64*1024] = {};
    // getShort(buffer, 20); // won't work because not using util namespace
    util::getShort(buffer, 20);
 
    using namespace util; // can also be put at begining of source file
    getShort(buffer, 20);
    return 0;    
}
 

Try it exactly with an empty project, except change the main function to the appropriate entry point. If it doesn't work, give me the results from the console window. And if it does, do a clean on your project you are having problems with and recompile it. It could be a phase error of some sort. If that don't help, give me the console from that compile.

Oh and if you don't mind, if it works or not, give me the version of the g++ compiler by typing the compiler name in a console window (you may have to run torVars.bat from the tornado bin directory to get the proper path and environment variables setup) with the parameter --version (that is two dashes). I'd be interested in how new their compiler is.

Hope this helps.


Adrian

[PaperPilot]

We started out using Tornado because it worked with 5.4 and the Motorola M68040 board. Other programmers on this project had been using Tornado with ADA on a companion system. I didn't put much effort into Tornado because I knew I would have to use Workbench when we converted to the PPC board and vxWorks 6.3. I began coding my section using Eclipse, CDT, and mingw on a PC. That was good enough for unit testing, although I couldn't CppUnit to run reliably. When we switched to workbench, management got a license for Solaris, so I am using the Exceed XTerm package to telnet to a Sun.



To answer your questions, the compiler is 3.4.4 I opened a an empty project as you suggested and made the following files:



main.h

#ifndef MAIN_H_
 
  #define MAIN_H_
 
  namespace util
 
  {
 
              template< typename T >
 
              T getVariable(char* buf, int from);
 
  } // end util
 
  #endif // MAIN_H_
 
 

main.cpp

# include "main.h"
 
  #include <memory>
 
  namespace util
 
  {
 
 
 
  template< typename T >
 
  T getVariable(char* buf, int from)
 
  {
 
              buf+=from;
 
 
 
              T tempVal;
 
              memcpy(&tempVal, buf , sizeof(T));
 
 
 
              return tempVal;
 
  }
 
 
 
  } // namespace util  

As you can see, I made my code generic. It saves some space and looks professional.



This complied without any errors and loaded without any unresolved links the first time.



I added this code as a test:

 
  #include <iostream>
 
  #include "main.h"
 
  using std::endl;
 
  using std::cout;
 
  using namespace util;
 
  void Test()
 
  {
 
              float testData = 34.68;
 
              char charArray[4];
 
              memcpy(&charArray, &testData, sizeof(float));
 
              cout << endl << getVariable< float >(charArray, 0) << endl;
 
  }
 
 

And it ran correctly. I went back to my original program and got more unresolved links. I fiddled around with the name space but couldn’t get it to work. Returned to the test program and got an unresolved link at load. So I am back where I started.

[AdrianH]

main.h

#ifndef MAIN_H_
 
  #define MAIN_H_
 
  namespace util
 
  {
 
              template< typename T >
 
              T getVariable(char* buf, int from);
 
  } // end util
 
  #endif // MAIN_H_
 
 

Your problem is right here. When making a template, the template code MUST be accessable to any code trying to use it, so put the body in the header file. No source, header seperation is allowed. This is for optimisation and memory allocation for the compiler.

Hope this helps.


Adrian

[PaperPilot]

Your problem is right here. When making a template, the template code MUST be accessable to any code trying to use it, so put the body in the header file. No source, header seperation is allowed. This is for optimisation and memory allocation for the compiler.

Hope this helps.


Adrian

Thanks, this will do. I can live with templates in the header file. I just wish I knew why the nongeneric code wouldn't separate. I just can't stand loose ends.

[AdrianH]

Thanks, this will do. I can live with templates in the header file. I just wish I knew why the nongeneric code wouldn't separate. I just can't stand loose ends.

I think you ment generic code in that statement didn't you? Anyway, you can write generic code, but it wouldn't using be a template. Trust me, I've done it in the project that I worked on when I was using VxWorks, and I did it in C. However, templates are generally faster.


Adrian