My problem is that I have header-file (custom unit-test framework) with function definitions in it. For example: unit_test.h: #pragma once ...     void Assert(bool b, const string&amp; hint = {}) {     AssertEqual(b, true, hint); } ...  it's convenient for me to keep some functions defined right in the header, because I often use this functional by simply including (unit_test.h is located in separate directory C:/Dev/include). But if I am dealing with a project where multiple cpp files use this functionality, I get a multiple definition error as expected. Simple project looks like: main.cpp: #include &quot;unit_test.h&quot;  void foo();  int main() {     Assert(1);     foo();     return 0; }  foo.cpp: #include &quot;unit_test.h&quot;  void foo() {     Assert(2); }  So I want to know if there is a right way to keep function definitions in a header file and use it in project without getting an multiple definition error? (Or would it be better to move the function definitions to the source and compile it separately each time, or compile unit_test into a static library?)
124139
I have a class which has many small functions. By small functions, I mean functions that doesn't do any processing but just return a literal value. Something like:  string Foo::method() const{     return "A"; }   I have created a header file "Foo.h" and source file "Foo.cpp". But since the function is very small, I am thinking about putting it in the header file itself. I have the following questions:   Is there any performance or other issues if I put these function definition in header file? I will have many functions like this. My understanding is when the compilation is done, compiler will expand the header file and place it where it is included. Is that correct?
45776
I'm trying to do something like the following:  enum E;  void Foo(E e);  enum E {A, B, C};   which the compiler rejects.  I've had a quick look on Google and the consensus seems to be "you can't do it", but I can't understand why.  Can anyone explain?  Clarification 2: I'm doing this as I have private methods in a class that take said enum, and I do not want the enum's values exposed - so, for example, I do not want anyone to know that E is defined as  enum E {     FUNCTIONALITY_NORMAL, FUNCTIONALITY_RESTRICTED, FUNCTIONALITY_FOR_PROJECT_X }   as project X is not something I want my users to know about.  So, I wanted to forward declare the enum so I could put the private methods in the header file, declare the enum internally in the cpp, and distribute the built library file and header to people.  As for the compiler - it's GCC.
35935
I'm using the 'using' declaration in C++ to add std::string and std::vector to the local namespace (to save typing unnecessary 'std::'s).  using std::string; using std::vector;  class Foo { /*...*/ };   What is the scope on this declaration?  If I do this in a header, will it inject these 'using' declarations into every cpp file that includes the header?
56496
This will hopefully be an easy one.  I have an F# project (latest F# CTP) with two files (Program.fs, Stack.fs).  In Stack.fs I have a simple namespace and type definition  Stack.fs  namespace Col  type Stack=   ...   Now I try to include the namespace in Program.fs by declaring  open Col   This doesn't work and gives me the error "The namespace or module Col is not defined."  Yet it's defined within the same project.  I've got to be missing something obvious
21491
Why does C++ have header files and .cpp files?
110498
That's it. If you want to document a function or a class, you put a string just after the definition. For instance:  def foo():     """This function does nothing."""     pass   But what about a module? How can I document what a file.py does?
33770
I have a very large codebase (read: thousands of modules) that has code shared across numerous projects that all run on different operating systems with different C++ compilers. Needless to say, maintaining the build process can be quite a chore.   There are several places in the codebase where it would clean up the code substantially if only there were a way to make the pre-processor ignore certain #includes if the file didn't exist in the current folder. Does anyone know a way to achieve that?  Presently, we use an #ifdef around the #include in the shared file, with a second project-specific file that #defines whether or not the #include exists in the project. This works, but it's ugly. People often forget to properly update the definitions when they add or remove files from the project. I've contemplated writing a pre-build tool to keep this file up to date, but if there's a platform-independent way to do this with the preprocessor I'd much rather do it that way instead. Any ideas?
11248
I'd like a simple example of exporting a function from a C++ Windows DLL.  I'd like to see the header, the .cpp file, and the .def file (if absolutely required).  I'd like the exported name to be undecorated. I'd like to use the most standard calling convention (__stdcall?). I'd like the use __declspec(dllexport) and not have to use a .def file.  For example:    //header   extern "C"   {    __declspec(dllexport) int __stdcall foo(long bar);   }    //cpp   int __stdcall foo(long bar)   {     return 0;   }   I'm trying to avoid the linker added underscores and/or numbers (byte counts?) to the name.   I'm OK with not supporting dllimport and dllexport using the same header. I don't want any information about exporting C++ class methods, just c-style global functions.  UPDATE  Not including the calling convention (and using extern "C") gives me the export names as I like, but what does that mean? Is whatever default calling convention I'm getting what pinvoke (.NET), declare (vb6), and GetProcAddress would expect? (I guess for GetProcAddress it would depend on the function pointer the caller created).  I want this DLL to be used without a header file, so I don't really need the a lot of the fancy #defines to make the header usable by a caller.  I'm OK with an answer being that I have to use a *.def file.
22784
What is the best way to unit test a method that calls into multiple methods, for example:  modify(string value) {     if(value.Length &gt; 5)  replaceit(value);      else changeit(value); }   This pseudo code has a modify method that (currently) calls either replaceit() or changeit(). I have already wrote tests for replaceit and changeit, so writing a new test for modify will be 99% the same set of code.  I need to test it thought because it may change in the future.    So do I copy paste the existing test code?  Move the test code to a common function?  Any other ideas?  I'm not sure of the best practice here.
8017
I often find myself in a situation where I am facing multiple compilation/linker errors in a C++ project due to some bad design decisions (made by someone else :) ) which lead to circular dependencies between C++ classes in different header files (can happen also in the same file). But fortunately(?) this doesn't happen often enough for me to remember the solution to this problem for the next time it happens again.  So for the purposes of easy recall in the future I am going to post a representative problem and a solution along with it. Better solutions are of-course welcome.     A.h  class B; class A {     int _val;     B *_b; public:      A(int val)         :_val(val)     {     }      void SetB(B *b)     {         _b = b;         _b-&gt;Print(); // COMPILER ERROR: C2027: use of undefined type 'B'     }      void Print()     {         cout&lt;&lt;"Type:A val="&lt;&lt;_val&lt;&lt;endl;     } };       B.h  #include "A.h" class B {     double _val;     A* _a; public:      B(double val)         :_val(val)     {     }      void SetA(A *a)     {         _a = a;         _a-&gt;Print();     }      void Print()     {         cout&lt;&lt;"Type:B val="&lt;&lt;_val&lt;&lt;endl;     } };       main.cpp  #include "B.h" #include &lt;iostream&gt;  int main(int argc, char* argv[]) {     A a(10);     B b(3.14);     a.Print();     a.SetB(&amp;b);     b.Print();     b.SetA(&amp;a);     return 0; }
60199
I am new to C++ and I had a few general questions about code separation. I have currently built a small application, all in one file.  What I want to do now is convert this into separate files such that they contain similar code or whatnot.  My real question right now is, how do I know how to separate things? What is the invisible margin that code should be separated at?    Also, what's the point of header files? Is it to forward declare methods and classes so I can use them in my code before they are included by the linker during compilation?    Any insight into methods or best practises would be great, thanks!
46741
In some code I've inherited, I see frequent use of size_t with the std namespace qualifier.  For example:  std::size_t n = sizeof( long );   It compiles and runs fine, of course.  But it seems like bad practice to me (perhaps carried over from C?).  Isn't it true that size_t is built into C++ and therefore in the global namespace?  Is a header file include needed to use size_t in C++?  Another way to ask this question is, would the following program (with no includes) be expected to compile on all C++ compilers?  size_t foo() {     return sizeof( long ); }
79031
As usual, when my brain's messing with something I can't figure out myself, I come to you guys for help :)  This time I've been wondering why stdafx.h works the way it does? To my understanding it does 2 things:   Includes standard headers which we might (?) use and which are rarely changed Work as a compiler-bookmark for when code is no longer precompiled.   Now, these 2 things seems like two very different tasks to me, and I wonder why they didn't do two seperate steps to take care of them? To me it seems reasonable to have a #pragma-command do the bookmarking stuff and to optionally have a header-file a long the lines of windows.h to do the including of often-used headers... Which brings me to my next point: Why are we forced to include often-used headers through stdafx.h? Personally, I'm not aware of any often used headers I use that I'm not already doing my own includes for - but maybe these headers are necessary for .dll generation?  Thx in advance
9623
In what segment (.BSS, .DATA, other) of an executable file are static variables stored so that they don't have name collision? For example:   foo.c:                         bar.c: static int foo = 1;            static int foo = 10; void fooTest() {               void barTest() {   static int bar = 2;            static int bar = 20;   foo++;                         foo++;   bar++;                         bar++;   printf("%d,%d", foo, bar);     printf("%d, %d", foo, bar); }                              }   If I compile both files and link it to a main that calls fooTest() and barTest repeatedly, the printf statements increment independently.  Makes sense since the foo and bar variables are local to the translation unit.  But where is the storage allocated?  To be clear, the assumption is that you have a toolchain that would output a file in ELF format.  Thus, I believe that there has to be some space reserved in the executable file for those static variables. For discussion purposes, lets assume we use the GCC toolchain.
29017
I'm asking for a template trick to detect if a class has a specific member function of a given signature.  The problem is similar to the one cited here  but not the same: in the item of Sutter's book he answered to the question that a class C MUST PROVIDE  a member function with a particular signature, else the program won't compile. In my problem I need to do something if a class has that function, else do "something else".   A similar problem was faced by boost::serialization but I don't like the solution they adopted: a template function that invokes by default a free function (that you have to define) with a particular signature unless you define a particular member function (in their case "serialize" that takes 2 parameters of a given type) with a particular signature, else a compile error will happens. That is to implement both intrusive and non-intrusive serialization.   I don't like that solution for two reasons:   To be non intrusive you must override the global "serialize" function that is in boost::serialization namespace, so you have IN YOUR CLIENT CODE to open namespace boost and namespace serialization! The stack to resolve that mess was 10 to 12 function invocations.   I need to define a custom behavior for classes that has not that member function, and my entities are inside different namespaces (and I don't want to override a global function defined in one namespace while I'm in another one)  Can you give me a hint to solve this puzzle?
55025
So I was just working with function pointers and I remembered that you could do this:  void Foo() { }  int main() {     void(&amp; func)() = Foo;      func(); //::Foo(); }   The obvious advantage being that references reference valid objects (unless they're misused), or functions in this case.  The obvious disadvantages being that you can't store an array of references and can't use them for member function pointers (at least as far as I can tell).  My question: does anyone use them (i.e., function references, not function pointers), and if so, in what scenarios have you found them useful/helpful?  The only place I can see them being useful off the bat is binding a reference to a certain function when working with conditional compilation.
19506
I have a function that is declared and defined in a header file. This is a problem all by itself. When that function is not inlined, every translation unit that uses that header gets a copy of the function, and when they are linked together there are duplicated. I "fixed" that by making the function inline, but I'm afraid that this is a fragile solution because as far as I know, the compiler doesn't guarantee inlining, even when you specify the "inline" keyword. If this is not true, please correct me.  Anyways, the real question is, what happens to static variables inside this function? How many copies do I end up with?