Geek Answers Handbook

Appropriate use of global constant variables in C ++?

I am working on a program for my CS class. This is a simulation of the delivery company at the airport.

This is a very simple small program consisting of several header and source files and a main.cpp source file that organizes the simulation.

There are certain predetermined constant values, such as the frequency of arrival of the cargo, the carrying capacity of the aircraft, the amount of time it takes the worker to process certain elements, etc. (all these are integer values). I need to access these variables in several functions in main.cpp

It seems reasonable to declare these main () functions as const ints, effectively making them global, for example.

const int kTotalTime = 2000;
const int kPlaneCapacity = 25;
int main(){//...program code}

I know that in most situations global variables should be avoided, since there are no restrictions on where they can be called and / or changed, which can lead to accidental violations of parts of the program, which, in turn, can be difficult to debug, and compatibility issues for future code, etc. However, since they are read-only values ​​of the primitive data type that are used throughout the program, this seemed like a reasonable solution. In addition, he makes an explicit statement about the purpose of variables for all who read the code, as well as the compiler.

Questions: Am I mistaken in my logic? How so? When is global variables (const or not) wise to use? If this is a bad decision, then how would you suggest declaring read-only constant values ​​like these?

Thanks so much for your time!

+5
3

( ), , , , , " ".

Config struct ( , , . ), . , , , , .

struct thingy ( , , ). const refs, , , ( ). - , . , (, ), .

- , , . ( ), OOP, . :

// footype.h
class FooType {
  private:
    static const int fooOption;
};
// bartype.h
class BarType {
  private:
    static const float barOption;
};

, . - config.cpp, :

#include "footype.h"
#include "bartype.h"

const int FooType::fooOption = 42;
const float BarType::barOption = 7.4;

, , (config.cpp).

:

, ( ) , ( ):

// footype.h
class FooType {
  private:
    static const int& fooOption;
    static const bool& dumpLevel;
};
// bartype.h
class BarType {
  private:
    static const float& barOption;
    static const bool& dumpLevel;
};

config.cpp:

#include "footype.h"
#include "bartype.h"

static const int opt_foo = 42;
static const float opt_bar = 7.4;
static const bool opt_dumpLevel = false;

const int& FooType::fooOption = opt_foo;
const bool& FooType::dumpLevel = opt_dumpLevel;
const float& BarType::barOption = opt_bar;
const bool& BarType::dumpLevel = opt_dumpLevel;

, ( , ).

+5

, .

, Plane, :

Plane.h

class Plane{
   static const int kPlaneCapacity;
   //....
}

Plane.cpp

const int Plane::kPlaneCapacity = 25;

, , . Pi - . 10 - . , , , : , , 30, 25.

+5

(const ) ?

, , , strong > . - .

:

. , . , . . , .

. . .

. , . , "" , ( , ). , , .

- , , , "" . , , , , .

, , , , .

+3

More articles:


All Articles