头文件基本上是预写的类吗？ C ++

Question

Exactly as it states in the title, are header files that you use the #include for basically prewritten/pre coded classes filled with methods and variable that you can use once you include it into your script. Also how can one go about making one to the point where you can simply use header files that you created for your own benefit? A simple explanation will do.

Answer 1

Yes and no... it depends on many things.

An include directive -as for the standard C++ is- can be two things:

#inlclude "filename"

and

#include <header>

The first one literally means "keep the text contained in "filename" and paste it here . So yes, the file can contain prewritten classes (but not necessaraily have to)

The second one means "let this source to use the facilities the standard defines in its <header> section. As per the standard definition goes, this is not necessarily meant to be a file, although all the implementation I'm today aware of in fact do: header is a file-name and <> and "" simply change the compiler search order.

You can -at this point- cut a "very long Cpp source" into smaller self-contained chunks and come to a cpp file that is nothing more than a sequence of #include and a main() .

But that's not all.

A C++ program is not necessarily made by a single cpp file (a cpp file plus everything it includes either directly or indirectly is called "translation unit").

In fact compilation does not produce programs, but "object files" (the term is "ancient operating system terminology", and have nothing to do with object-oriented programming) that a "linker" puts together.

Because a C++ function calling another does not need -to be translated- to know how the other function is translated, but only how its parameters and return values have to be passed and taken, This makes you able to write the other function body in another independently compiled source and let the header to contain only its declaration (not definition).

For example you can have

// fooclass.h
#ifndef FOOCLASS_H
#define FOOCLASS_H
class foo
{
public:
   void hello();
   void bye();
};
#endif // FOOCLASS_H

,

// out.h
#ifndef OUT_H
#define OUT_H 
#include <string>
void printout(const std::string& s);
#endif // OUT_H

,

//main.cpp
#include "fooclass.h"
int main()
{
   foo afoo;
   afoo.hello();
   afoo.bye();
}

,

// fooclass.cpp
#include "fooclass.h"
#include "out.h"

void foo::hello()
{ printout("hello"); }

void foo::bye()
{ printout("bye"); }

,

// out.cpp
#include "out.h"
#include <iostream>

void printout(const std::string& s)
{ std::cout << "- " << s << " -" << std::endl; }

The entire program can be compiled (for example with GCC) as

g++ main.cpp fooclass.cpp out.cpp

or in separated step as

g++ -c main.cpp
g++ -c fooclass.cpp
g++ -c out.cpp
g++ main.o fooclass.o out.o

(if you use MS compilers, you'll most likely do

cl /c main.cpp
cl /c fooclass.cpp
cl /c out.cpp
link main.obj fooclass.obj out.obj

)

Only the last step makes up the program (note that main.cpp will never know about the printout function!). The previous three are required only for files that have been changed, thus on big projects can speed up compilation and distribute tasks to different teams. (there are utiities like make , that allow to automate this thing.

There is an exception to all that, that nowadays is more and more important: templates . Since they are not implemented as "code to be translated" but as "code to be expanded", they can be translated only when what they have to expand is known.

template<class T>
T max(const T& a, const T& b)
{ return (a<b)? b: a; }

The meaning of (a<b) depends own what the type T actually is. And since it is know only when max is called, max can be expanded as max<int> or max<double> or max<string> only when used.

For this reason, templates are not normally handled in independent translation units and library offering template classes or functions do that by just providing collection of headers containing all the code, with no source to compile separately.

Answer 2

are header files that you use the #include for basically prewritten/pre coded classes filled with methods and variable that you can use once you include it into your script?

That's the general concept. In C++, not everything needs to be in a class, so there can be non-member functions, types, preprocessor definitions, variables etc. too. Further, some headers declare variables, types and/or functions but do not define them - that means you can make limited use of them and generally have to present the matching implementation object at link or run-time.

Also how can one go about making one to the point where you can simply use header files that you created for your own benefit?

There's no particular magic about it (though there're linking issues above to learn about if you put implementation out-of-line), but to start with just throw some code in a file:

#pragma once
...

...then #include it from another file. If the including file is in directory "X", then you can include headers in directory "X" using eg #include "the_header.h" - with double-quoted header filename - even if the include directory is not specified to the compiler as a command line argument.

If you have something in your header that's declared but not defined, then you will want a matching .cc/.cpp file with the definition, which you should compile into an object and link with the code using the library. For example:

mylib.h
    #pragma one
    int fn();  // declared but not defined

mylib.cc
    #include "mylib.h"
    int fn() { return 42; }   // matching definition

cc -c mylib      // compile mylib.o

app.cc
    #include "mylib.h"
    int main()
    {
        return fn();
    }

cc -o app mylib.o

Answer 3

A common use for header files in c++ is to define methods or classes without having to implement them. It's defining an interface, or telling other parts of your program how it can interact with them. It lets the files doing the including know what they need to know about those classes/methods without telling everything they don't. In the case of methods, you know there's a method doSomethingCool, and you know how to interact with it. As long as you know that you can generally just #include whatever header file doSomethingCool is defined in, and then the linker does its magic at compile time and finds where you called doSomethingCool and "hooks it up" so to speak to the actual implementation code, which you may write say in doSomethingCool.cpp.

Works with functions, classes and variables.