I&#39;m looking to create two classes, each of which contains an object of the other class type. How can I do this? If I can&#39;t do this, is there a work-around, like having each class contain a *pointer* to the other class type? Thanks!

Here&#39;s what I have:

File: **bar.h**

    #ifndef BAR_H
    #define BAR_H
    #include &quot;foo.h&quot;
    class bar {
    public:
      foo getFoo();
    protected:
      foo f;
    };
    #endif

File: **foo.h**

    #ifndef FOO_H
    #define FOO_H
    #include &quot;bar.h&quot;
    class foo {
    public:
      bar getBar();
    protected:
      bar b;
    };
    #endif

File: **main.cpp**

    #include &quot;foo.h&quot;
    #include &quot;bar.h&quot;
    
    int
    main (int argc, char **argv)
    {
      foo myFoo;
      bar myBar;
    }


*$ g++ main.cpp*

    In file included from foo.h:3,
                     from main.cpp:1:
    bar.h:6: error: ‘foo’ does not name a type
    bar.h:8: error: ‘foo’ does not name a type

How to create two classes in C++ which use each other as data?

I&#39;d like to store the version number of my library in just one place. So I have defined such a variable in the CMake-file:

        SET(LIBINTERFACE_VERSION 1 CACHE INTEGER &quot;Version of libInterface&quot;)

With this definition I can generate a version.rc file according to Microsoft&#39;s definition, which I compile into the library and afterwards shows up correctly in the properties window of my dll-file.

Now I&#39;d like to use this CMake variable in my c++ source code too, but I actually don&#39;t get to a working solution. I&#39;ve tried different things like this:

        #ifndef VERSION_LIBINTERFACE
        #  define VERSION_LIBINTERFACE @LIBINTERFACE_VERSION@
        #endif

or this:

        unsigned int getLibInterfaceVersion()
        {
        	return @LIBINTERFACE_VERSION@;
        }

But the compiler won&#39;t accept anything. Since my researches in the CMake-Documentation didn&#39;t get any results, I hope that someone could give me the essential advice.

Thanks in advance.


How to read a CMake Variable in C++ source code

**COMPILER:**  *g++ 4.7.2*

Ok. So I am confused about default parameters in `.h` and `.cpp` files. It is mentioned in many places( including this site) that default parameters can be added only in .h files and not in .cpp files. 
However, this code proves it wrong:

**test1.h**

    #pragma once
    
    #include &lt;iostream&gt;
    using namespace std;
    
    class Class{
    public:
    	Class(int, int, int=1);
    };


**test1.cpp**

    #include &quot;test1.h&quot;
    
    Class::Class(int a, int b=2, int c)
    {
    	cout&lt;&lt;a&lt;&lt;&quot; &quot;&lt;&lt;b&lt;&lt;&quot; &quot;&lt;&lt;c&lt;&lt;endl;
    }
    
    int main()
    {
    	Class a(1);
    	return 0;
    }

Now, according to what I have tested, default parameters can be added to `.cpp` files. However, the following restrictions hold:

 1. The default parameters present in `.cpp` and `.h` file should not
    overlap. i.e. `Class(a, b, c=1)` (in .h file) and
    `Class::Class(a,b,c=2)`( in .cpp file) is invalid.
    
    It is a well known rule that once default parameters have been
    added, all the variables declared after that must also contain
    default values. Lets call this the *defpara* rule. Now,
 2. The variables stated in the function declaration( `.h` file) should
    obey the *defpara* rule i.e. `Class(a, b=2, c)` (in .h file)  is
    invalid irrespective of what&#39;s declared in .cpp file.

 3. If one considers the variables having default values (as an
    intersection of default values in `.h` and `.cpp` files), it would
    follow the *defpara* rule. i.e. `Class(a, b, c=1)` (in .h file) and
    `Class::Class(a,b=2,c)`( in `.cpp` file) is valid. But `Class(a, b,
    c=1)` (in .h file) and `Class::Class(a=2,b,c)`( in `.cpp` file) is
    invalid.


So....I am right, wrong???

default parameters in .h and .cpp files

I have a project (a library) that is subdivided into a few directories with code in them. I&#39;d like to to have g++ search for header files in the project&#39;s root directory, so I can avoid different include paths for same header files across multiple source files.

Mainly, the `root/` directory has sub-directories `A/`, `B/` and `C/`, all of which have `.hpp` and `.cpp` files inside. If some source file in A wanted to include `file.hpp`, which was in B, it would have to do it like this: `#include &quot;../B/file.hpp&quot;`. Same for another source file that was in C. But, if A itself had sub-directories with files that needed `file.hpp`, then, it would be inconsistent and would cause errors if I decided to move files (because the include path would be `&quot;../../B/file.hpp&quot;`).

Also, this would need to work from other projects as well, which reside outside of `root/`. I already know that there is an option to manually copy all my header files into a default-search directory, but I&#39;d like to do this the way I described.

**Edit:** all programs using the library must compile only with `g++ prog.cpp lib.a -o prog`. That means *permanently* setting the include path for g++!

How to make g++ search for header files in a specific directory?

Is it safe (and correct) in a C++ header file to use the using declaration within a namespace as follows:

    #include &lt;boost/numeric/ublas/vector.hpp&gt;
    namespace MyNamespace {
        using boost::numeric::ublas::vector;
        vector MyFunc(vector in);
    }

I.e. is the &quot;using boost::numeric::ublas::vector&quot; properly contained within the MyNamespace block, or will this pollute the namespace of any file that includes this header?

scope of using declaration within a namespace

I am using CMake on a small C++ project and so far it works great... with one twist :x

When I change a header file, it typically requires recompiling a number of sources files (those which include it, directly or indirectly), however it seems that cmake only detects *some* of the source files to be recompiled, leading to a corrupted state. I can work around this by wiping out the project and rebuilding from scratch, but this circumvents the goal of using a make utility: only recompiling what is needed.

Therefore, I suppose I am doing something wrong.

My project is very simply organized:

 - a top directory where all resources sit, the main CMakeLists.txt sits there
 - a &quot;include&quot; directory where all public headers lies (in various subdirectories)
 - a &quot;src&quot; directory where all the subdirectories for sources files are, the src CMakeLists.txt sits there
 - a CMakeLists.txt per subdirectory in the &quot;src&quot; directory

The main directory has:

    cmake_minimum_required(VERSION 2.8)
    
    project(FOO)
    
    set(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin)
    
    # Compiler Options
    set(CMAKE_CXX_FLAGS &quot;${CMAKE_CXX_FLAGS} -g -std=c++0x -Wall -Wextra -Werror&quot;)
    
    include_directories($(FOO_SOURCE_DIR)/include)
    
    add_subdirectory(src)

The &quot;src&quot; directory:

    add_subdirectory(sub1)
    add_subdirectory(sub2)
    add_subdirectory(sub3)
    add_subdirectory(sub4)
    
    add_executable(foo main.cpp)
    
    target_link_libraries(foo sub1 sub2 sub3 sub4)

Where `sub4` depends on `sub3` which depends on `sub2` which depends on `sub1`

And an example of a subdirectory (sub3):

    set(SUB3_SRCS
        File1.cpp
        File2.cpp
        File3.cpp
        File4.cpp
        File5.cpp
        File6.cpp
        )
    
    add_library(sub3 ${SUB3_SRCS})
    
    target_link_libraries(sub3 sub1 sub2)

I&#39;d be glad if anyone could point my mistake to me, searching here or on CMake didn&#39;t yield anything so I guess it&#39;s very easy or should work out of the box...

(for reference, I am using cmake version 2.8.2 on MSYS)

**EDIT**:

Thanks to Bill&#39;s suggestion I have checked the `depend.make` file generated by CMake, and it is indeed lacking (severely). Here is an example:

    src/sub3/CMakeFiles/sub3.dir/File1.cpp.obj: ../src/sub3/File1.cpp

Yep, that&#39;s all, none of the includes were referenced at all :x


Handling header files dependencies with cmake

In what cases should we include **cassert**?



In what cases we need to include &lt;cassert&gt;?

You can structure a C++ program so that (almost) all the code resides in Header files. It essentially looks like a C# or Java program. However, you do need at least one `.cpp` file to pull in all the header files when compiling. Now I know some people would absolutely detest this idea. But I haven&#39;t found any convincing downsides of doing this. I can list some advantages:

[1] Faster compile times. All header files only get parsed once, because there is only one .cpp file. Also, one header file cannot be included more than once, otherwise you will get a build break. There are other ways of achieving faster compiles when using the alternate approach, but this is so simple.

[2] It avoids circular dependencies, by making them absolutely clear. If `ClassA` in `ClassA.h` has a circular dependency on `ClassB` in `ClassB.h`, I have to put a forward reference &amp; it sticks out. (Note that this is unlike C# &amp; Java where the compiler automatically resolves circular dependencies. This encourages bad coding practices IMO). Again, you can avoid circular dependencies if your code was in `.cpp` files, but in a real-world project, `.cpp` files tend to include random headers until you can&#39;t figure out who depends on whom.

Your thoughts?

Pros &amp; Cons of putting all code in Header files in C++?

&gt; **Possible Duplicates:**  
&gt; [*.h or *.hpp for your class definitions](https://stackoverflow.com/questions/152555/h-or-hpp-for-your-class-definitions)  
&gt; [Correct C++ code file extension? .cc vs .cpp](https://stackoverflow.com/questions/1545080/correct-c-code-file-extension-cc-vs-cpp)  

&lt;!-- End of automatically inserted text --&gt;

I used to think that it used to be that:

 * `.h` files are header files for C and C++, and usually only contain declarations.
 * `.c` files are C source code.
 * `.cpp` files are C++ source code (which can also be C source code).

then files like `.hpp`, `.cc`, and `.cxx` came along, and I got totally confused... what&#39;s the difference(s) between those? When do you use the &quot;new&quot; ones?

.c vs .cc vs. .cpp vs .hpp vs .h vs .cxx

So I finished my first C++ programming assignment and received my grade. But according to the grading, I lost marks for `including cpp files instead of compiling and linking them`. I&#39;m not too clear on what that means.

Taking a look back at my code, I chose not to create header files for my classes, but did everything in the cpp files (it seemed to work fine without header files...). I&#39;m guessing that the grader meant that I wrote &#39;#include &quot;mycppfile.cpp&quot;;&#39; in some of my files. 

My reasoning for `#include`&#39;ing the cpp files was: 
- Everything that was supposed to go into the header file was in my cpp file, so I pretended it was like a header file
- In monkey-see-monkey do fashion, I saw that other header files were `#include`&#39;d in the files, so I did the same for my cpp file.

So what exactly did I do wrong, and why is it bad?

Why should I not include cpp files and instead use a header?

Which header files provide the intrinsics for the different x86 SIMD instruction set extensions (MMX, SSE, AVX, ...)? It seems impossible to find such a list online. Correct me if I&#39;m wrong.

Header files for x86 SIMD intrinsics

Traditionally, the standard and portable way to avoid multiple header inclusions in C++ was/is  to use the `#ifndef - #define - #endif`pre-compiler directives scheme also called [macro-guard scheme][1] (see code snippet below).

    #ifndef MY_HEADER_HPP
    #define MY_HEADER_HPP
    ...
    #endif

In most implementations/compilers (see picture below) however, there&#39;s a more &quot;elegant&quot; alternative that serves the same purpose as the macro-guard scheme called [`#pragma once`][2]. `#pragma once` has several advantages compared to the macro-guard scheme, including less code, avoidance of name clashes, and sometimes improved compile speed.

![enter image description here][4]

Doing some research, I realized that although `#pragma once` directive is supported by almost all known compilers, there&#39;s a turbidness on whether `#pragma once` directive is part of the C++11 standard or not.

**Questions:**
--------------

- Could someone clarify whether `#pragma once` directive is part of the C++11 standard or not?
- If it&#39;s not part of the C++11 standard, are there any plans on including it on later releases (e.g., C++14 or later)?
- It would also be nice if someone could further elaborate on the advantages/disadvantages in using either one of the techniques (i.e., macro-guard versus `#pragma once`).

  [1]: http://en.wikipedia.org/wiki/Include_guard
  [2]: http://en.wikipedia.org/wiki/Pragma_once
  [3]: http://en.wikipedia.org/wiki/Pragma_once
  [4]: http://i.stack.imgur.com/qDohP.png

Is #pragma once part of the C++11 standard?

In the C and C++ programming languages, what is the difference between using angle brackets and using quotes in an `include` statement, as follows?

1. `#include &lt;filename&gt;` 
1. `#include &quot;filename&quot;`

What is the difference between #include &lt;filename&gt; and #include &quot;filename&quot;?

In all our c++ courses, all the teachers always put `using namespace std;` right after the `#include`s in their `.h` files. This seems to me to be dangerous since then by including that header in another program I will get the namespace imported into my program, maybe without realizing, intending or wanting it (header inclusion can be very deeply nested).

So my question is double: Am I right that `using namespace` should not be used in header files, and/or is there some way to undo it, something like:

    //header.h
    using namespace std {
    .
    .
    .
    }

One more question along the same lines: Should a header file `#include` all the headers that it&#39;s corresponding `.cpp` file needs, only those that are needed for the header definitions and let the `.cpp` file `#include` the rest, or none and declare everything it needs as `extern`?  
The reasoning behind the question is the same as above: I don&#39;t want surprises when including `.h` files.

Also, if I am right, is this a common mistake? I mean in real-world programming and in &quot;real&quot; projects out there.

Thank you.

&quot;using namespace&quot; in c++ headers

When dividing your code up into multiple files just what exactly should go into an .h file and what should go into a .cpp file? 

What should go into an .h file?

Let&#39;s say I have a makefile with the rule

    %.o: %.c
     gcc -Wall -Iinclude ...

I want *.o to be rebuilt whenever a header file changes. Rather than work out a list of dependencies, whenever any header file in `/include` changes, then all objects in the dir must be rebuilt. 

I can&#39;t think of a nice way to change the rule to accomodate this, I&#39;m open to suggestions. Bonus points if the list of headers doesn&#39;t have to be hard-coded 

Makefile, header dependencies

Why does C++ have header files and .cpp files?


Why have header files and .cpp files?

Ok, not a C/C++ expert by any means, but I thought the point of a header file was to declare the functions, then the C/CPP file was to define the implementation.

However, reviewing some C++ code tonight, I found this in a class&#39;s header file...

    public:
        UInt32 GetNumberChannels() const { return _numberChannels; } // &lt;-- Huh??

    private:
        UInt32 _numberChannels;

So why is there an implementation in a header? Does it have to do with the `const` keyword? Does that inline a class method? What exactly is the benefit/point of doing it this way vs. defining the implementation in the CPP file?


How can a C++ header file include implementation?

Consider a pair of two source files: an interface declaration file (`*.h` or `*.hpp`) and its implementation file (`*.cpp`).

Let the `*.h` file be like the following:

    namespace MyNamespace {
      class MyClass {
      public:
        int foo();
      };
    }

I have seen two different practices for using namespaces in source files:

`*.cpp` showing practice #1:

    #include &quot;MyClass.h&quot;
    using namespace MyNamespace;
    
    int MyClass::foo() { ... }

`*.cpp` showing practice #2:

    #include &quot;MyClass.h&quot;
    namespace MyNamespace {
    
      int MyClass::foo() { ... }
    
    }

**My question:** Are there any differences between these two practices and is one considered better than the other?

C++: Namespaces -- How to use in header and source files correctly?

Is it good practice when writing C++11 code to set default values for class members in the header file of the class?

Or is it better to do this in the constructor of the class?

EDIT:

I mean:

**foo.h**:

    #include &lt;string&gt;
    
    using std::string;
    
    class Foo{
        private:
            string greet = &quot;hello&quot;;
        public:
            Foo();
    };

VS

**foo.cpp** (of course with the necessary header file, but without the in-class initialization):

    Foo::Foo(){
        greet = &quot;hello&quot;;
    }


Which one is better and why?

Default member values best practice

&gt; **Possible Duplicate:**  
&gt; [How to implement getch() function of C in Linux?](https://stackoverflow.com/questions/3276546/how-to-implement-getch-function-of-c-in-linux)  

&lt;!-- End of automatically inserted text --&gt;

What is the equivalent `Linux` version of the `conio.h` header file from MS-DOS?

Is there a way to replace its functionality? *e.g. `getch()`*

&gt; I&#39;m using `gcc` and the text editor `Geany` to compile `C` code.



Where is the &lt;conio.h&gt; header file on Linux? Why can&#39;t I find &lt;conio.h&gt;?

Normally we use 

    @interface interface_name : parent_class &lt;delegates&gt;
    {
    ......
    }
    @end 

method in .h file and in .m file we synthesis the properties of variables declared in .h file.

But in some code, this @interface.....@end method is kept in the .m file also. What does it mean?  What is the difference between them?

Also give some words about getters and setters for the interface file that is defined in .m file...


Thanks in Advance

Difference between @interface definition in .h and .m file

I am sending file from client to server using TCP. To mark the end of the file I like to send file size before the actual data. So I use `stat` system call to find the size of the file. This is of type `off_t`. I like to know how many bytes it occupies so that I can read it properly on the server side. It is defined in the  `&lt;sys/types.h&gt;`. But I do not understand the definition. It just defines `__off_t or _off64_t` to be `off_t`. Where to look for `__off_t`? Also is it convention that `__` is prefixed for most of the things in header files and scares me when I read header files to understand better. How to read a header file better?

    #ifndef __off_t_defined
    # ifndef __USE_FILE_OFFSET64
    typedef __off_t off_t;
    # else
    typedef __off64_t off_t;
    # endif
    # define __off_t_defined
    #endif 

Where to find the complete definition of off_t type?

I recently installed `lxml`.

Before that, I had to install all the dependencies for that.
So I tried to install `liblxml2-dev`, `liblxslt1-dev` and `python-dev`
(google-searched for what packages are required for `lxml`)
but even after that, I could not able to install `lxml` by using the command
`pip install lxml`.

However as because I am using Python 3.4.0, I thought that may be there are different version of `python-dev` (thought came due to facing some similar version conflict problem). So I tried to install `python3-dev`.

Then I tried to install `lxml` using the same command said earlier and that worked!!!

I google-searched for those sentences
and I could able to understand the meaning of `lxml` and `xslt`. I found a [link][1] for `python-dev` but I am not still sure what it is actually doing.

OS - Ubuntu

  [1]: https://packages.debian.org/sid/python-dev

What is python-dev package used for

Two common questions about [include guards](http://en.wikipedia.org/wiki/Include_guard):

1. **FIRST QUESTION:**

    Why aren&#39;t include guards protecting my header files from **mutual, recursive inclusion**? I keep getting errors about non-existing symbols which are obviously there or even weirder syntax errors every time I write something like the following:
    
    &quot;a.h&quot;
    
        #ifndef A_H
        #define A_H
    
        #include &quot;b.h&quot;
    
        ...
    
        #endif // A_H
    
    &quot;b.h&quot;
    
        #ifndef B_H
        #define B_H
    
        #include &quot;a.h&quot;
    
        ...
    
        #endif // B_H
    
    &quot;main.cpp&quot;
    
        #include &quot;a.h&quot;
        int main()
        {
            ...
        }
    
    Why do I get errors compiling &quot;main.cpp&quot;? What do I need to do to solve my problem?

---

2. **SECOND QUESTION:**

    Why aren&#39;t include guards preventing **multiple definitions**? For instance, when my project contains two files that include the same header, sometimes the linker complains about some symbol being defined multiple times. For instance:
    
    &quot;header.h&quot;

        #ifndef HEADER_H
        #define HEADER_H
    
        int f()
        {
            return 0;
        }
    
        #endif // HEADER_H
    
    &quot;source1.cpp&quot;
    
        #include &quot;header.h&quot;
        ...
    
    &quot;source2.cpp&quot;
    
        #include &quot;header.h&quot;
        ...
    
    Why is this happening? What do I need to do to solve my problem?



Why aren&#39;t my include guards preventing recursive inclusion and multiple symbol definitions?

I know [PC-Lint][1] can tell you about headers which are included but not used.  Are there any other tools that can do this, preferably on linux?

We have a large codebase that through the last 15 years has seen plenty of functionality move around, but rarely do the leftover #include directives get removed when functionality moves from one implementation file to another, leaving us with a pretty good mess by this point.  I can obviously do the painstaking thing of removing all the #include directives and letting the compiler tell me which ones to reinclude, but I&#39;d rather solve the problem in reverse - find the unused ones - rather than rebuilding a list of used ones.


  [1]: http://www.gimpel.com/

Tools to find included headers which are unused?

I&#39;m successfully calling my Swift classes from Objective C (for target &#39;MyApp&#39;) via the import statement:

    #import &quot;MyApp-Swift.h&quot;

I&#39;ve now created a new target called &quot;MyAppLite&quot;

When I compile the new target, I get errors because &quot;MyApp-Swift.h&quot; is required by the code, but the compiler is creating &quot;MyAppLite-Swift.h&quot;

So, I need to create a conditional Swift/ObjC header `#import` for the target I&#39;m compiling against.  

How can this be done, or is there a better way?

Objective C to Swift header file with multiple targets

Many languages, such as Java, C#,  do not separate declaration from implementation. C# has a concept of partial class, but implementation and declaration still remain in the same file. 

Why doesn&#39;t C++ have the same model? Is it more practical to have header files?

I am referring to current and upcoming versions of C++ standard. 


Should C++ eliminate header files?

When I write C programs in Linux, and then compile them using gcc, I am always curious about where those header files are. For example, where `stdio.h` is. More generally, where is `stdbool.h`?

What I want to know is not only where it is, but also how to get those places, for example, using shell command or using the C programming language.

How can I find the header files of the C programming language in Linux?

Why in a project should I include some *.lib, .h or some other files? And what are these things used for?


What&#39;s the differences between .dll , .lib, .h files?

I&#39;ve perused the possible duplicates, however none of the answers there are sinking in.

**tl;dr: How are source and header files related in `C`? Do projects sort out declaration/definition dependencies implicitly at build time?**

I&#39;m trying to understand how the compiler *understands* the relationship between `.c` and `.h` files.

Given these files:

**header.h**:

    int returnSeven(void);

**source.c**:

    int returnSeven(void){
        return 7;
    }

**main.c**:

    #include &lt;stdio.h&gt;
    #include &lt;stdlib.h&gt;
    #include &quot;header.h&quot;
    int main(void){
        printf(&quot;%d&quot;, returnSeven());
        return 0;
    }

Will this mess compile? I&#39;m currently doing my work in **NetBeans 7.0** with **gcc** from Cygwin which automates much of the build task. When a project is compiled will the project files involved sort out this implicit inclusion of `source.c` based on the declarations in `header.h`?

How do header and source files in C work?

I have a class which has many small functions. By small functions, I mean functions that doesn&#39;t do any processing but just return a literal value. Something like:

    string Foo::method() const{
    	return &quot;A&quot;;
    }

I have created a header file &quot;Foo.h&quot; and source file &quot;Foo.cpp&quot;. But since the function is very small, I am thinking about putting it in the header file itself. I have the following questions:

 1. Is there any performance or other issues if I put these function definition in header file? I will have many functions like this.
 2. My understanding is when the compilation is done, compiler will expand the header file and place it where it is included. Is that correct?


Writing function definition in header files in C++

Is there any way to not have to write function declarations twice (headers) and still retain the same scalability in compiling, clarity in debugging, and flexibility in design when programming in C++?

Can I write C++ code without headers (repetitive function declarations)?

The tool [`include-what-you-use`](http://include-what-you-use.org) can be used to detect unneeded headers. I am using [CMake](http://www.cmake.org) for my C++ software project. How can I instruct CMake to run include-what-you-use automatically on the source files of my software project?

How to use the tool include-what-you-use together with CMake to detect unused headers?

I am getting a really odd error from GCC 4.8.1 with inline functions.

I have two near-identical inline functions defined in header files (`debug.h` and `error.h`) in `src/include/`, with the only difference being what they print - one prefixes `DEBUG: ` to the message, and the other `%s: error: %s` (program name, error message). When defining the functions both inline, and compiling a debug build (so it sets the macro `DEBUG=1`), I get lots of undefined reference errors:

    src/main_debug.o
      gcc -osrc/main_debug.o src/main.c -c -Wall -Wextra -Wpedantic -std=gnu11 -march=native -Og -g -DCC=&quot;\&quot;gcc\&quot;&quot; -DCFLAGS=&quot;\&quot;-Wall -Wextra -Wpedantic -std=gnu11 -march=native -Og -g\&quot;&quot; -DDEBUG=1 -DBTCWATCH_VERSION=&quot;\&quot;0.0.1\&quot;&quot;
    
    src/lib/btcapi_debug.o
      gcc -osrc/lib/btcapi_debug.o src/lib/btcapi.c -c -Wall -Wextra -Wpedantic -std=gnu11 -march=native -Og -g -DCC=&quot;\&quot;gcc\&quot;&quot; -DCFLAGS=&quot;\&quot;-Wall -Wextra -Wpedantic -std=gnu11 -march=native -Og -g\&quot;&quot; -DDEBUG=1
    
    src/lib/libbtcapi_debug.a
      ar rc src/lib/libbtcapi_debug.a src/lib/btcapi_debug.o
      ranlib src/lib/libbtcapi_debug.a
    
    src/lib/cmdlineutils_debug.o
      gcc -o src/lib/cmdlineutils_debug.o src/lib/cmdlineutils.c -c -Wall -Wextra -Wpedantic -std=gnu11 -march=native -Og -g -DCC=&quot;\&quot;gcc\&quot;&quot; -DCFLAGS=&quot;\&quot;-Wall -Wextra -Wpedantic -std=gnu11 -march=native -Og -g\&quot;&quot; -DDEBUG=1
    
    src/lib/libcmdlineutils_debug.a
      ar rc src/lib/libcmdlineutils_debug.a src/lib/cmdlineutils_debug.o
      ranlib src/lib/libcmdlineutils_debug.a
    
    debug
      gcc -obtcwatch-debug src/main_debug.o -Lsrc/lib/ -lbtcapi_debug -lcmdlineutils_debug -lcurl  -ljansson 
    src/main_debug.o: In function `main&#39;:
    /home/marcoms/btcwatch/src/main.c:148: undefined reference to `debug&#39;
    src/main_debug.o:/home/marcoms/btcwatch/src/main.c:185: more undefined references to `debug&#39; follow
    collect2: error: ld returned 1 exit status
    make: *** [debug] Error 1

But changing `debug()`&#39;s definition to `static inline` removes the errors. But I have never received any errors from `error()`&#39;s definition, although its defenition is `inline`, and not `static inline`.

The definitions are all in headers (i.e. not prototyped)

undefined reference when calling inline function

I&#39;m trying to compile miniSAT on Kali Linux 64 bits but I keep getting the error message:

&gt; fatal error: zlib.h: no such file or directory

I have read that there might be a linking problem that makes the compiler unable to find the header files, but I&#39;m new to Linux and do not know how to solve that.

How to fix fatal error: zlib.h: no such file or directory?

I want to be able to create a collection of functions in a header file that I could #include in one of my C Programs.

How can I create C header files

How come this code

	std::map &lt;std::string , int&gt; m;
    m[&quot;a&quot;]=1;



 compiles with (I&#39;m using MSVC 2010)

    #include &lt;string&gt;
but not with

    #include &lt;string.h&gt;
?


All Header Files Solutions on Gang of Coders

Total of 38 Header Files Solutions