Définir des variables constantes dans l'en-tête C++

Un programme sur lequel je travaille beaucoup constantes qui s'appliquent à l'ensemble de toutes les classes. Je veux faire un fichier d'en-tête des "Constantes.h", et être en mesure de déclarer que toutes les constantes. Alors dans mes autres classes, je peux juste inclure #include "Constants.h.

Je l'ai eu à travailler très bien avec #ifndef ... #define ... de la syntaxe. Cependant, je préfère utiliser le const int... forme de constantes. Je ne suis pas tout à fait sûr de savoir comment bien.

  • Pouvez-vous expliquer ce que vous ne comprenez pas concernant const int? Post un exemple de code qui n'ont pas pu compiler si c'est votre question?
InformationsquelleAutor | 2012-08-20
  1. 76

    Vous pouvez simplement définir une série de const ints dans un fichier d'en-tête:

    //Constants.h
#if !defined(MYLIB_CONSTANTS_H)
#define MYLIB_CONSTANTS_H 1

const int a = 100;
const int b = 0x7f;

#endif

    Cela fonctionne car en C++ un nom d'espace de noms de champ d'application (y compris l'espace de noms global) qui est explicitement déclarée const et non explicitement déclaré extern a une liaison interne, de sorte que ces variables ne serait pas causer des doubles symboles lorsque vous liez ensemble d'unités de traduction. Vous pouvez également déclarer explicitement les constantes static.

    static const int a = 100;
static const int b = 0x7f;

    C'est plus compatible avec le C et plus lisible pour les personnes qui peuvent ne pas être familiers avec le C++ règles d'assemblage.

    Si toutes les constantes sont des entiers alors une autre méthode que vous pouvez utiliser est de déclarer les identificateurs les énumérations.

    enum mylib_constants {
    a = 100;
    b = 0x7f;
};

    Toutes ces méthodes utilisent seulement un en-tête et de permettre à l'déclaré noms utilisés compiler des constantes de temps. À l'aide de extern const int et la mise en œuvre de fichier empêche les noms d'être utilisé comme compiler les constantes de temps.

    Note que la règle qui fait que certaines constantes implicitement une liaison interne ne s'appliquent à des pointeurs, exactement comme des constantes d'autres types. La chose la plus délicate, c'est que le marquage d'un pointeur comme const nécessite une syntaxe un peu différente que la plupart des gens utilisent pour faire des variables d'autres types de const. Ce que vous devez faire:

    int * const ptr;

    de faire un pointeur constant, de sorte que la règle va s'appliquer à elle.

    Noter également que c'est une des raisons, je préfère privilégier const après le type: int const au lieu de const int. J'ai aussi mis le * en regard de la variable: c'est à dire int *ptr; au lieu de int* ptr;.

    J'aime faire ces sortes de choses, parce qu'elles reflètent le cas général de la façon dont C++ fonctionne vraiment. Les solutions de rechange (const int, int* p) sont juste spéciales tubé à faire quelques choses simples, plus lisibles. Le problème est que quand tu sors de ces cas simples, le tubé alternatives activement trompeuse.

    Ainsi, bien que les exemples précédents montrent l'usage commun de la const, en fait, je peux recommander les gens écrire comme ceci:

    int const a = 100;
int const b = 0x7f;

    et 

    static int const a = 100;
static int const b = 0x7f;
    • Votre règle implicite d'une liaison statique ne fonctionne pas avec les pointeurs
    • Il ne, cependant, vous devez assurez-vous de mettre le const dans le bon endroit. Faire un pointeur const nécessite de placer le const après la *. E. g. int * const x. Si vous venez d'utiliser const int *x; puis le const se réfère à ce que le pointeur pointe de et de pas le pointeur lui-même.
    InformationsquelleAutor bames53
  2. 26

    J'aime la espace de noms mieux pour ce genre de but.

    Option 1 :

    #ifndef MYLIB_CONSTANTS_H
#define MYLIB_CONSTANTS_H

// File Name : LibConstants.hpp    Purpose : Global Constants for Lib Utils
namespace LibConstants
{
  const int CurlTimeOut = 0xFF;     //Just some example
  ...
}
#endif

//source.cpp
#include <LibConstants.hpp>
int value = LibConstants::CurlTimeOut;

    Option 2 :

    #ifndef MYLIB_CONSTANTS_H
#define MYLIB_CONSTANTS_H
// File Name : LibConstants.hpp    Purpose : Global Constants for Lib Utils
namespace CurlConstants
{
  const int CurlTimeOut = 0xFF;     //Just some example
  ...
}

namespace MySQLConstants
{
  const int DBPoolSize = 0xFF;      //Just some example
  ...
}
#endif



//source.cpp
#include <LibConstants.hpp>
int value = CurlConstants::CurlTimeOut;
int val2  = MySQLConstants::DBPoolSize;

    Et je n'aurais jamais utiliser une Classe pour organiser ce type d'codé en dur Const variables.

    InformationsquelleAutor Manikandaraj Srinivasan
  3. 12

    En général, vous ne devriez pas utiliser, par exemple, const int dans un fichier d'en-tête, si c'est inclus dans plusieurs fichiers source. C'est parce que les variables seront définis une fois par fichier source (unités de traduction techniquement parlant) car mondiale const les variables sont implicitement statique, en prenant plus de mémoire que nécessaire.

    Vous devriez plutôt avoir une source particulière de fichier, Constants.cpp qui définit en fait les variables, et alors les variables déclarées comme extern dans le fichier d'en-tête.

    Quelque chose comme ce fichier d'en-tête:

    //Protect against multiple inclusions in the same source file
#ifndef CONSTANTS_H
#define CONSTANTS_H

extern const int CONSTANT_1;

#endif

    Et ce dans un fichier source:

    const int CONSTANT_1 = 123;
    • Est-ce à dire que ma solution ne fonctionne pas?
    • Pas si vous voulez utiliser un seul fichier d'en-tête. Voir ma réponse révisée.
    • Il serait mieux de l'initialiser dans l'en-tête, de sorte qu'il peut être utilisé comme une constante de compilation.
    • Aussi, vous peut utiliser const int dans un fichier d'en-tête, depuis const variables ont une liaison interne par défaut. Si vous voulez que, plutôt qu'un seul exemple, c'est une autre question; en général, il fait peu de différence, tant que la valeur est disponible dans l'en-tête.
    • Cette réponse est la bonne, et doit être marqué de la sorte.
    • C++17 inline variables sont encore plus génial façon d'atteindre cet objectif pour ceux qui peuvent utiliser cette version: stackoverflow.com/a/53541011/895245

    InformationsquelleAutor Some programmer dude
  4. 5

    C++17 inline variables

    Ce génial C++17 fonction de nous permettre de:

    • utilisation pratique d'une seule adresse de mémoire pour chaque constante
    • le stocker en tant que constexpr: Comment déclarer constexpr extern?
    • le faire en une seule ligne à partir d'un en-tête

    main.cpp

    #include <cassert>

#include "notmain.hpp"

int main() {
    //Both files see the same memory address.
    assert(&notmain_i == notmain_func());
    assert(notmain_i == 42);
}

    notmain.php

    #ifndef NOTMAIN_HPP
#define NOTMAIN_HPP

inline constexpr int notmain_i = 42;

const int* notmain_func();

#endif

    notmain.cpp

    #include "notmain.hpp"

const int* notmain_func() {
    return &notmain_i;
}

    Compiler et exécuter:

    g++ -c -o notmain.o -std=c++17 -Wall -Wextra -pedantic notmain.cpp
g++ -c -o main.o -std=c++17 -Wall -Wextra -pedantic main.cpp
g++ -o main -std=c++17 -Wall -Wextra -pedantic main.o notmain.o
./main

    GitHub en amont.

    Voir aussi: Comment puis-inline variables de travail?

    C++ standard inline sur les variables

    La norme C++ garantit que les adresses seront les mêmes. C++17 N4659 projet de norme
    10.1.6 "La ligne spécificateur":

    6 Une fonction inline ou variable, avec une liaison externe doit avoir la même adresse dans toutes les unités de traduction.

    cppreference https://en.cppreference.com/w/cpp/language/inline explique que si static n'est pas donné, alors il a une liaison externe.

    Variable Inline mise en œuvre

    Nous pouvons observer comment il est mis en œuvre avec:

    nm main.o notmain.o

    qui contient:

    main.o:
                 U _GLOBAL_OFFSET_TABLE_
                 U _Z12notmain_funcv
0000000000000028 r _ZZ4mainE19__PRETTY_FUNCTION__
                 U __assert_fail
0000000000000000 T main
0000000000000000 u notmain_i

notmain.o:
0000000000000000 T _Z12notmain_funcv
0000000000000000 u notmain_i

    et man nm dit à propos de u:

    "u" Le symbole est un unique symbole mondial. C'est une extension GNU à l'ensemble standard de ELF symbole de liaisons. Pour un symbole de l'éditeur de liens dynamique sera assurez-vous que dans l'ensemble du processus
    il y a juste un symbole avec ce nom et type de l'utilisation.

    nous voyons donc qu'il y a un ELFE de la prolongation pour cette.

    C++17 projet de norme sur le "global" const implique static

    C'est la citation pour ce qui a été mentionné à: https://stackoverflow.com/a/12043198/895245

    C++17 n4659 projet de norme 6.5 "Programme" et de liaison":

    3
    Un nom ayant portée espace de noms (6.3.6) a une liaison interne si c'est le nom de

    • (3.1) — une variable, une fonction ou une fonction modèle est explicitement déclarée statique; ou,
    • (3.2) — un non-inline variable de non-volatile const qualifiés de type qui n'est ni explicitement déclaré extern ni
      auparavant déclaré avoir une liaison externe; ou
    • (3.3) — un membre de données d'un anonyme de l'union.

    "espace de noms" portée est ce que nous familièrement souvent référence en tant que "global".

    L'annexe C (informative) Compatibilité, C. 1.2
    Article 6: "concepts de base" donne la raison pour laquelle cela a été modifié à partir de C:

    6.5 [aussi 10.1.7]

    Changement: Un nom de fichier de la portée qui est explicitement déclarée const, et non explicitement déclaré extern, a
    une liaison interne, alors qu'en C il aurait une liaison externe.

    Justification: Parce que const objets peuvent être utilisés comme valeurs lors de la traduction en C++, cette fonction demande instamment à
    les programmeurs de formuler explicitement initialiseur pour chaque const objet. Cette fonctionnalité permet à l'utilisateur de mettre
    const objets dans les fichiers sources qui sont inclus dans plus d'une unité de traduction.

    Effet sur la fonction originale: Changement de sémantique bien définie fonctionnalité.

    De la difficulté de la conversion: Sémantique de la transformation.

    Comment largement utilisé: Rarement.

    Voir aussi: Pourquoi ne const implique une liaison interne en C++, quand il n'est pas dans C?

    Testé dans GCC 7.4.0, Ubuntu 18.04.

    InformationsquelleAutor Ciro Santilli 新疆改造中心法轮功六四事件
  5. 1

    Plutôt que de faire un tas de variables globales, vous pouvez envisager de créer une classe qui a un tas de public static constantes. C'est toujours globale, mais de cette façon, il est enveloppé dans une classe de sorte que vous savez où la constante est à venir et que c'est censé être une constante.

    Constantes.h

    #ifndef CONSTANTS_H
#define CONSTANTS_H

class GlobalConstants {
  public:
    static const int myConstant;
    static const int myOtherConstant;
};

#endif

    Constants.cpp

    #include "Constants.h"

const int GlobalConstants::myConstant = 1;
const int GlobalConstants::myOtherConstant = 3;

    Alors vous pouvez l'utiliser comme ceci:

    #include "Constants.h"

void foo() {
  int foo = GlobalConstants::myConstant;
}
    • Pourquoi voudriez-vous utiliser une classe pour émuler un espace de noms, quand vous pouvez simplement utiliser un espace de noms?
    InformationsquelleAutor Andrew Rasmussen
  6. 0

    Il semble que bames53 de réponse peut être prolongé à la définition entier et non entier les valeurs des constantes dans l'espace de noms et la classe déclarations même si ils sont inclus dans plusieurs fichiers sources. Il n'est pas nécessaire de mettre les déclarations dans un fichier d'en-tête, mais les définitions dans un fichier source. L'exemple suivant fonctionne pour Microsoft Visual Studio 2015, pour z/OS V2.2 XL C/C++ sur OS/390, et pour g++ (GCC) 8.1.1 20180502 sur GNU/Linux 4.16.14 (Fedora 28). Notez que les constantes sont déclarées/défini dans un seul fichier d'en-tête est inclus dans plusieurs fichiers source.

    Dans foo.cc:

    #include <cstdio>               //for puts

#include "messages.hh"
#include "bar.hh"
#include "zoo.hh"

int main(int argc, const char* argv[])
{
  puts("Hello!");
  bar();
  zoo();
  puts(Message::third);
  return 0;
}

    Dans les messages.hh:

    #ifndef MESSAGES_HH
#define MESSAGES_HH

namespace Message {
  char const * const first = "Yes, this is the first message!";
  char const * const second = "This is the second message.";
  char const * const third = "Message #3.";
};

#endif

    Dans bar.cc:

    #include "messages.hh"
#include <cstdio>

void bar(void)
{
  puts("Wow!");
  printf("bar: %s\n", Message::first);
}

    Dans zoo.cc:

    #include <cstdio>
#include "messages.hh"

void zoo(void)
{
  printf("zoo: %s\n", Message::second);
}

    Dans la barre.hh:

    #ifndef BAR_HH
#define BAR_HH

#include "messages.hh"

void bar(void);

#endif

    Dans zoo.hh:

    #ifndef ZOO_HH
#define ZOO_HH

#include "messages.hh"

void zoo(void);

#endif

    Cela donne le résultat suivant:

    Hello!
Wow!
bar: Yes, this is the first message!
zoo: This is the second message.
Message #3.

    Le type de données char const * const désigne une constante pointeur vers un tableau de caractères constante. La première const est nécessaire parce que (en fonction de g++) "ISO C++ forbids la conversion d'une chaîne constante de 'char*'". La deuxième const est nécessaire pour éviter les erreurs de liaison due à de multiples définitions de l' (alors insuffisamment constante) constantes. Votre compilateur peut pas se plaindre si vous omettez l'une ou des deux consts, mais le code source est moins portable.

    InformationsquelleAutor Louis Strous