«const estática» frente a «#define» frente a «enumeración»

En este artículo, analizaremos «static const», «#define» y «enum» . Estos tres a menudo son confusos y elegir cuál usar a veces puede ser una tarea difícil.

constante estática

static const : “static const” es básicamente una combinación de static (un especificador de almacenamiento) y const (un calificador de tipo).

Estático: determina el tiempo de vida y la visibilidad/accesibilidad de la variable. Esto significa que si una variable se declara como variable estática, permanecerá en la memoria todo el tiempo que el programa se esté ejecutando, mientras que las variables normales o automáticas se destruyen cuando finaliza la función (donde se definió la variable).
Const : es un calificador de tipo. Un calificador de tipo se usa para expresar información adicional sobre un valor a través del sistema de tipos. Cuando una variable se inicializa usando el calificador de tipo const, no aceptará más cambios en su valor.
Entonces, combinando static y const, podemos decir que cuando una variable se inicializa usando static const, conservará su valor hasta la ejecución del programa y, además, no aceptará ningún cambio en su valor.

Sintaxis:

static const data_type name_of_variable = initial_value;

// C++ program to demonstrate the use of
// static const
  
#include <bits/stdc++.h>
  
using namespace std;
// function to add constant value to input
int addConst(int input)
{
    // value = 5 will be stored in
    // memory even after the
    // execution of the
    // function is finished
    static const int value = 5;
  
    // constant_not_static will
    // not accept change in value
    // but it will get destroyed
    // after the execution of
    // function is complete
    const int constant_not_static = 13;
    input += value;
  
    // value++; ==> this statement will produce error
    return input;
}
  
int main()
{
    int input = 10;
    cout << addConst(input) << endl;
  
    return 0;
}

15

“¿Qué es # definir “?

A menudo se malinterpreta como una instrucción de programación. Pero en realidad configura una macro . Una macro hace que se reemplace un texto antes de que tenga lugar la compilación. Para saber más acerca de las macros, consulte el artículo macros_vs_function .

Sintaxis:

#define token [value]

NOTA: el token no debe tener espacios, el valor puede tener espacios.
Ejemplo:

 #define ll long long int

// C++ program to demonstrate
// the use of #define
  
#include <bits/stdc++.h>
  
// defining long long int as => ll
#define ll long long int
  
// defining for loop
#define f(i, a, b, c) for (ll i = a; i < b; i += c)
using namespace std;
  
// function to count to a given number
void count(ll input)
{
    // loop implemented using macros
    // for(long long int j=1; j<input+1;j+=1)
    f(j, 1, input + 1, 1)
    {
        cout << j << " ";
    }
    cout << endl;
}
  
int main()
{
    // ll will get replaced by
    // long long int
    ll num = 10;
    count(num);
  
    return 0;
}

1 2 3 4 5 6 7 8 9 10

¿Qué es la enumeración?

La enumeración es un tipo de datos definido por el usuario. Se utiliza para asignar nombres a constantes integrales para mejorar la legibilidad del código. Para usar la enumeración, la palabra clave «enum» se usa en C/C++.

Sintaxis:

enum flag{constant1= 2, constant2=3, constant3=4....};

Lo que hace que «enum» sea diferente de «#define» es que automáticamente asigna valores a las variables. En el ejemplo anterior si los valores no fueron asignados=>

enum{constant1, constant2, constantd3...}

A las variables se les asignarán los valores automáticamente (constante1= 0, constante2= 1, constante3= 2…). Hay varias ventajas de usar enum en lugar de macros. Uno de ellos es la asignación automática de valores.

// C++ program to demonstrate
// the use of enum
  
#include <bits/stdc++.h>
  
using namespace std;
  
int main()
{
    // declaring weekdays data type
    enum weekdays { mon,
                    tues,
                    wed,
                    thurs,
                    fri,
                    sat,
                    sun };
    // a variable named day1 holds the value of wed
    enum weekdays day1 = wed;
  
    // mon holds 0, tue holds 1 and so on
    cout << "The value stored in wed is :" << day1 << endl;
  
    // looping through the values of
    // defined integral constants
    for (int i = mon; i <= sun; i++)
        cout << i << " ";
    cout << endl;
  
    return 0;
}

The value stored in wed is :2
0 1 2 3 4 5 6

Para obtener más información sobre la enumeración, consulte el artículo Enumeración (o enumeración) en C.