Brtdku

I have seen header file code something like this:

#ifndef GS

#define GS



struct GS gs {

public:

    int n;

    gs(int n) : n{ n } {}

};



#endif // !GS

What is the purpose of using GS in struct GS gs? The code works exactly the same if I remove it.

I am pretty new to C++. I tried to search this on google without success.

You are right that there is no change in the behavior of the code.
There is no apparent benefit from the code you show.

This is because

#define GS

Defines GS as nothing, so after the preprocessor finishes, there is no difference from not including it in the declaration of the struct.

struct gs {

What could be the reason would be if there is some other tool that reads the code before the preprocessor and marks some kind of usage.

Note: in the comments, you reference other code. That code may, depending on other flags, set the macro to something, such as BOOST_SYMBOL_EXPORT. That then may have specific meaning. These kinds of usage are often used for marking classes as export or import depending on what the compiler is doing at the time.

Base on your comment your refer to this:

struct TORRENT_EXPORT storage_interface {

}

Where TORRENT_EXPORT might be defined as #define TORRENT_EXPORT

These kind of macros are use to enable system/compile/environment dependent options.

In case of TORRENT_EXPORT to enable the export of the symbols if it should be use as dynamic linke library:

#if defined(_MSC_VER)

    //  Microsoft 

    #define TORRENT_EXPORT __declspec(dllexport)

    #define TORRENT_IMPORT __declspec(dllimport)

#elif defined(__GNUC__)

    //  GCC

    #define TORRENT_EXPORT __attribute__((visibility("default")))

    #define TORRENT_IMPORT

#else

    #define TORRENT_EXPORT

    #define TORRENT_IMPORT

    #pragma warning Unknown dynamic link import/export semantics.

#endif

Or can be used for other pre or post processing scripts as markers to find the definitions easier. (e.g. to create API documentations, to create glue APIs to scripting languages, ...)

In other cases it is used to enable language features only if the compiler supports it (like constexpr)

The only visible benefit for such code is to make sure that the macro is used for the purpose of guards and nothing else, even accidentally.

See below scenario:

// file1.h

#define GS 1234



// file2.h    

#ifndef GS

#define GS  // defined for the guarding purpose



#include"file1.h"  // "GS" re-defined for different purpose  



// the redefinition will result in compiler error, due to adding guard in `struct` definition

struct GS gs { ... };



#endif

Modern compilers will give warning for re-define of a macro.

Nevertheless, such guard doesn't harm in anyway and provides a little benefit to avoid any accidental redefinition.

Usually modern IDE-s will create the guard in a unique way, which includes the file extension with extra underscores _ such as:

#ifndef GS_H_

#define GS_H_

Hence, such extra check may not be required, because any developer wouldn't tend to create the file-like macros.

A purpose of a macro is that it is replaced by something else (whatever that macro is defined to be) by the pre processor.

Specifically, placing a macro between class-key and the class name (such as in your example), will let the macro control the attribute sequence of the class. For example, if you define the macro to be empty (such as in your example), then the class will have an empty attribute sequence:

#define GS

struct GS gs {

// same as

struct gs {

But a macro can be defined to be non-empty:

#define GS alignas(8)

struct GS gs {

// same as

struct alignas(8) gs {

Macros can be passed as an argument to the tool chain upon compilation, thereby toggling a feature on or off. Macros can also be used to detect the target system and thereby enable system specific code - thereby allowing a system dependent program work on multiple systems.

Another purpose of a macro is to prevent a header from being included twice. Such macro is called a header guard. Using the same macro for both a header guard, and content replacement (such as in your example) is confusing and unconventional.