Tipos De Variables Dev C++
- Tipos De Variables Programacion
- Tipos De Variables Estadisticas
- Tabla De Tipos De Variables En Dev C++
Hay dos clases de tipos en C#: tipos de valor y tipos de referencia.There are two kinds of types in C#: value types and reference types.Las variables de tipos de valor contienen directamente los datos, mientras que las variables de los tipos de referencia almacenan referencias a los datos, lo que se conoce como objetos.Variables of value types directly contain their data whereas variables of reference types store references to their data, the latter being known as objects.Con los tipos de referencia, es posible que dos variables hagan referencia al mismo objeto y que, por tanto, las operaciones en una variable afecten al objeto al que hace referencia la otra.With reference types, it's possible for two variables to reference the same object and thus possible for operations on one variable to affect the object referenced by the other variable.Con los tipos de valor, cada variable tiene su propia copia de los datos y no es posible que las operaciones en una variable afecten a la otra (excepto para las variables de parámetro ref
y out
).With value types, the variables each have their own copy of the data, and it isn't possible for operations on one to affect the other (except for ref
and out
parameter variables).
Feb 12, 2020 🎯 Tutorial Variables y Tipos de Datos en C con DEV C 2020 👨🏿💻. Para definir variables de tipo cadena, estas se definen como vectores de caracteres, esto es, anteponiendo la palabra reservada char al identificador de la variable. Por defecto, Dev-C crea el archivo main.c, pero lo borramos ya que queremos aprender a programar desde el principio.
Los tipos de valor de C# se dividen en tipos simples, tipos de enumeración, tipos de estructura y tipos de valores NULL.C#’s value types are further divided into simple types, enum types, struct types, and nullable value types.Los tipos de referencia de C# se dividen en tipos de clase, tipos de interfaz, tipos de matriz y tipos delegados.C#’s reference types are further divided into class types, interface types, array types, and delegate types.
En el esquema siguiente se proporciona información general del sistema de tipos de C#.The following outline provides an overview of C#’s type system.
- Tipos de valorValue types
- Tipos simplesSimple types
- Entero con signo:
sbyte
,short
,int
,long
Signed integral:sbyte
,short
,int
,long
- Entero sin signo:
byte
,ushort
,uint
,ulong
Unsigned integral:byte
,ushort
,uint
,ulong
- Caracteres Unicode:
char
Unicode characters:char
- Punto flotante binario IEEE:
float
,double
IEEE binary floating-point:float
,double
- Punto flotante decimal de alta precisión:
decimal
High-precision decimal floating-point:decimal
- Booleano:
bool
Boolean:bool
- Entero con signo:
- Tipos de enumeraciónEnum types
- Tipos definidos por el usuario con el formato
enum E {..}
User-defined types of the formenum E {..}
- Tipos definidos por el usuario con el formato
- Tipos de estructuraStruct types
- Tipos definidos por el usuario con el formato
struct S {..}
User-defined types of the formstruct S {..}
- Tipos definidos por el usuario con el formato
- Tipos de valores que aceptan valores NULLNullable value types
- Extensiones de todos los demás tipos de valor con un valor
null
Extensions of all other value types with anull
value
- Extensiones de todos los demás tipos de valor con un valor
- Tipos simplesSimple types
- Tipos de referenciaReference types
- Tipos de claseClass types
- Clase base definitiva de todos los demás tipos:
object
Ultimate base class of all other types:object
- Cadenas Unicode:
string
Unicode strings:string
- Tipos definidos por el usuario con el formato
class C {..}
User-defined types of the formclass C {..}
- Clase base definitiva de todos los demás tipos:
- Tipos de interfazInterface types
- Tipos definidos por el usuario con el formato
interface I {..}
User-defined types of the forminterface I {..}
- Tipos definidos por el usuario con el formato
- Tipos de matrizArray types
- Unidimensional y multidimensional; por ejemplo,
int[]
yint[,]
Single- and multi-dimensional, for example,int[]
andint[,]
- Unidimensional y multidimensional; por ejemplo,
- Tipos delegadosDelegate types
- Tipos definidos por el usuario con el formato
delegate int D(..)
User-defined types of the formdelegate int D(..)
- Tipos definidos por el usuario con el formato
- Tipos de claseClass types
Para obtener más información sobre los tipos numéricos, vea Tipos enteros y Tabla de tipos de punto flotante.For more information about numeric types, see Integral types and Floating-point types table.
El tipo bool
de C# se utiliza para representar valores booleanos; valores que son true
o false
.C#’s bool
type is used to represent Boolean values—values that are either true
or false
.
El procesamiento de caracteres y cadenas en C# utiliza la codificación Unicode.Character and string processing in C# uses Unicode encoding.El tipo char
representa una unidad de código UTF-16 y el tipo string
representa una secuencia de unidades de código UTF-16.The char
type represents a UTF-16 code unit, and the string
type represents a sequence of UTF-16 code units.
Los programas de C# utilizan declaraciones de tipos para crear nuevos tipos.C# programs use type declarations to create new types.Una declaración de tipos especifica el nombre y los miembros del nuevo tipo.A type declaration specifies the name and the members of the new type.Cinco de las categorías de tipos de C# las define el usuario: tipos de clase, tipos de estructura, tipos de interfaz, tipos de enumeración y tipos delegados.Five of C#’s categories of types are user-definable: class types, struct types, interface types, enum types, and delegate types.
A tipo class
define una estructura de datos que contiene miembros de datos (campos) y miembros de función (métodos, propiedades y otros).A class
type defines a data structure that contains data members (fields) and function members (methods, properties, and others).Los tipos de clase admiten herencia única y polimorfismo, mecanismos por los que las clases derivadas pueden extender y especializar clases base.Class types support single inheritance and polymorphism, mechanisms whereby derived classes can extend and specialize base classes.
Un tipo struct
es similar a un tipo de clase, por el hecho de que representa una estructura con miembros de datos y miembros de función.A struct
type is similar to a class type in that it represents a structure with data members and function members.Pero a diferencia de las clases, las estructuras son tipos de valor y no suelen requerir la asignación del montón.However, unlike classes, structs are value types and don't typically require heap allocation.Los tipos de estructura no admiten la herencia especificada por el usuario y todos se heredan implícitamente del tipo object
.Struct types don't support user-specified inheritance, and all struct types implicitly inherit from type object
.
Un tipo interface
define un contrato como un conjunto con nombre de miembros de función públicos.An interface
type defines a contract as a named set of public function members.Un class
o struct
que implementa un interface
debe proporcionar implementaciones de miembros de función de la interfaz.A class
or struct
that implements an interface
must provide implementations of the interface’s function members.Un interface
puede heredar de varias interfaces base, y un class
o struct
pueden implementar varias interfaces.An interface
may inherit from multiple base interfaces, and a class
or struct
may implement multiple interfaces.
Un tipo delegate
representa las referencias a métodos con una lista de parámetros determinada y un tipo de valor devuelto.A delegate
type represents references to methods with a particular parameter list and return type.Los delegados permiten tratar métodos como entidades que se puedan asignar a variables y se puedan pasar como parámetros.Delegates make it possible to treat methods as entities that can be assigned to variables and passed as parameters.Los delegados son análogos a los tipos de función proporcionados por los lenguajes funcionales.Delegates are analogous to function types provided by functional languages.También son similares al concepto de punteros de función de otros lenguajes.They're also similar to the concept of function pointers found in some other languages.A diferencia de los punteros de función, los delegados están orientados a objetos y tienen seguridad de tipos.Unlike function pointers, delegates are object-oriented and type-safe.
Los tipos class
, struct
, interface
y delegate
admiten parámetros genéricos, mediante los que se pueden parametrizar con otros tipos.The class
, struct
, interface
, and delegate
types all support generics, whereby they can be parameterized with other types.
Un tipo enum
es un tipo distinto con constantes con nombre.An enum
type is a distinct type with named constants.Cada tipo enum
tiene un tipo subyacente, que debe ser uno de los ocho tipos enteros.Every enum
type has an underlying type, which must be one of the eight integral types.El conjunto de valores de un tipo enum
es igual que el conjunto de valores del tipo subyacente.The set of values of an enum
type is the same as the set of values of the underlying type.
C# admite matrices unidimensionales y multidimensionales de cualquier tipo.C# supports single- and multi-dimensional arrays of any type.A diferencia de los tipos enumerados antes, no es necesario declarar los tipos de matriz antes de usarlos.Unlike the types listed above, array types don't have to be declared before they can be used.En su lugar, los tipos de matriz se crean mediante un nombre de tipo entre corchetes.Instead, array types are constructed by following a type name with square brackets.Por ejemplo, int[]
es una matriz unidimensional de int
, int[,]
es una matriz bidimensional de int
y int[][]
es una matriz unidimensional de la matriz unidimensional de int
.For example, int[]
is a single-dimensional array of int
, int[,]
is a two-dimensional array of int
, and int[][]
is a single-dimensional array of single-dimensional array of int
.
Jun 09, 2018 Compile and run C program in Ubuntu Linux. When you install build-essential the core part is done, you are ready to jump and compile program in Linux. Assuming you can code in C, here our main goal is on how you can compile and run C programs in Linux. For instance, you have a example.cpp (cpp is a standard extension for program). Nov 29, 2016 Download Dev-C for free. A free, portable, fast and simple C/C IDE. A new and improved fork of Bloodshed Dev-C. Dev c++ linux. Get notifications on updates for this project. Get the SourceForge newsletter. Get newsletters and notices that include site news, special offers and exclusive discounts about IT products & services. Dev-C is a full-featured Integrated Development Environment (IDE) for the C/C programming language. It uses Mingw port of GCC (GNU Compiler Collection) as its compiler.
Tampoco es necesario declarar los tipos que admiten un valor NULL antes de usarlos.Nullable value types also don't have to be declared before they can be used.Para cada tipo de valor T
que no acepta valores NULL, existe un tipo de valor T?
que admite un valor NULL correspondiente, que puede tener un valor adicional, null
.For each non-nullable value type T
, there is a corresponding nullable value type T?
, which can hold an additional value, null
.Por ejemplo, int?
es un tipo que puede contener cualquier número entero de 32 bits o el valor null
.For instance, int?
is a type that can hold any 32-bit integer or the value null
.
El sistema de tipos de C# está unificado, de tal forma que un valor de cualquier tipo puede tratarse como un object
.C#’s type system is unified such that a value of any type can be treated as an object
.Todos los tipos de C# directa o indirectamente se derivan del tipo de clase object
, y object
es la clase base definitiva de todos los tipos.Every type in C# directly or indirectly derives from the object
class type, and object
is the ultimate base class of all types.Los valores de tipos de referencia se tratan como objetos mediante la visualización de los valores como tipo object
.Values of reference types are treated as objects simply by viewing the values as type object
.Los valores de tipos de valor se tratan como objetos mediante la realización de operaciones de conversión boxing y operaciones de conversión unboxing.Values of value types are treated as objects by performing boxing and unboxing operations.En el ejemplo siguiente, un valor int
se convierte en object
y vuelve a int
.In the following example, an int
value is converted to object
and back again to int
.
Cuando se convierte un valor de un tipo de valor al tipo object
, se asigna una instancia object
, también denominada 'box', para contener el valor, y el valor se copia en dicho box.When a value of a value type is converted to type object
, an object
instance, also called a 'box', is allocated to hold the value, and the value is copied into that box.Por el contrario, cuando se convierte una referencia object
en un tipo de valor, se comprueba si la referencia object
es un box del tipo de valor correcto y, si la comprobación es correcta, se copia el valor del box.Conversely, when an object
reference is cast to a value type, a check is made that the referenced object
is a box of the correct value type, and, if the check succeeds, the value in the box is copied out.
El sistema de tipos unificado de C# conlleva efectivamente que los tipos de valor pueden convertirse en objetos 'a petición'.C#’s unified type system effectively means that value types can become objects 'on demand.'Debido a la unificación, las bibliotecas de uso general que utilizan el tipo object
pueden usarse con tipos de referencia y tipos de valor.Because of the unification, general-purpose libraries that use type object
can be used with both reference types and value types.
Hay varios tipos de variables en C#, entre otras, campos, elementos de matriz, variables locales y parámetros.There are several kinds of variables in C#, including fields, array elements, local variables, and parameters.Las variables representan ubicaciones de almacenamiento, y cada variable tiene un tipo que determina qué valores pueden almacenarse en la variable, como se muestra a continuación.Variables represent storage locations, and every variable has a type that determines what values can be stored in the variable, as shown below.
- Tipo de valor distinto a NULLNon-nullable value type
- Un valor de ese tipo exactoA value of that exact type
- Tipos de valor NULLNullable value type
- Un valor
null
o un valor de ese tipo exactoAnull
value or a value of that exact type
- Un valor
- objetoobject
- Una referencia
null
, una referencia a un objeto de cualquier tipo de referencia o una referencia a un valor de conversión boxing de cualquier tipo de valorAnull
reference, a reference to an object of any reference type, or a reference to a boxed value of any value type
- Una referencia
- Tipo de claseClass type
- Una referencia
null
, una referencia a una instancia de ese tipo de clase o una referencia a una instancia de una clase derivada de ese tipo de claseAnull
reference, a reference to an instance of that class type, or a reference to an instance of a class derived from that class type
- Una referencia
- Tipo de interfazInterface type
- Un referencia
null
, una referencia a una instancia de un tipo de clase que implementa dicho tipo de interfaz o una referencia a un valor de conversión boxing de un tipo de valor que implementa dicho tipo de interfazAnull
reference, a reference to an instance of a class type that implements that interface type, or a reference to a boxed value of a value type that implements that interface type
- Un referencia
- Tipo de matrizArray type
- Una referencia
null
, una referencia a una instancia de ese tipo de matriz o una referencia a una instancia de un tipo de matriz compatibleAnull
reference, a reference to an instance of that array type, or a reference to an instance of a compatible array type
- Una referencia
- Tipo delegadoDelegate type
- Una referencia
null
o una referencia a una instancia de un tipo delegado compatibleAnull
reference or a reference to an instance of a compatible delegate type
- Una referencia
However, programming is not limited only to printing simple texts on the screen. In order to go a little further on and to become able to write programs that perform useful tasks that really save us work, we need to introduce the concept of variables.
Let's imagine that I ask you to remember the number 5, and then I ask you to also memorize the number 2 at the same time. You have just stored two different values in your memory (5 and 2). Now, if I ask you to add 1 to the first number I said, you should be retaining the numbers 6 (that is 5+1) and 2 in your memory. Then we could, for example, subtract these values and obtain 4 as result.
The whole process described above is a simile of what a computer can do with two variables. The same process can be expressed in C++ with the following set of statements:
Obviously, this is a very simple example, since we have only used two small integer values, but consider that your computer can store millions of numbers like these at the same time and conduct sophisticated mathematical operations with them.
We can now define variable as a portion of memory to store a value.
Each variable needs a name that identifies it and distinguishes it from the others. For example, in the previous code the variable names were
a
, b
, and result
, but we could have called the variables any names we could have come up with, as long as they were valid C++ identifiers.Identifiers
A valid identifier is a sequence of one or more letters, digits, or underscore characters (_
). Spaces, punctuation marks, and symbols cannot be part of an identifier. In addition, identifiers shall always begin with a letter. They can also begin with an underline character (_
), but such identifiers are -on most cases- considered reserved for compiler-specific keywords or external identifiers, as well as identifiers containing two successive underscore characters anywhere. In no case can they begin with a digit.C++ uses a number of keywords to identify operations and data descriptions; therefore, identifiers created by a programmer cannot match these keywords. The standard reserved keywords that cannot be used for programmer created identifiers are:
alignas, alignof, and, and_eq, asm, auto, bitand, bitor, bool, break, case, catch, char, char16_t, char32_t, class, compl, const, constexpr, const_cast, continue, decltype, default, delete, do, double, dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, noexcept, not, not_eq, nullptr, operator, or, or_eq, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_assert, static_cast, struct, switch, template, this, thread_local, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t, while, xor, xor_eq
Specific compilers may also have additional specific reserved keywords.
Very important: The C++ language is a 'case sensitive' language. That means that an identifier written in capital letters is not equivalent to another one with the same name but written in small letters. Thus, for example, the
RESULT
variable is not the same as the result
variable or the Result
variable. These are three different identifiers identifiying three different variables.Fundamental data types
The values of variables are stored somewhere in an unspecified location in the computer memory as zeros and ones. Our program does not need to know the exact location where a variable is stored; it can simply refer to it by its name. What the program needs to be aware of is the kind of data stored in the variable. It's not the same to store a simple integer as it is to store a letter or a large floating-point number; even though they are all represented using zeros and ones, they are not interpreted in the same way, and in many cases, they don't occupy the same amount of memory.Fundamental data types are basic types implemented directly by the language that represent the basic storage units supported natively by most systems. They can mainly be classified into:
- Character types: They can represent a single character, such as
'A'
or'$'
. The most basic type ischar
, which is a one-byte character. Other types are also provided for wider characters. - Numerical integer types: They can store a whole number value, such as
7
or1024
. They exist in a variety of sizes, and can either be signed or unsigned, depending on whether they support negative values or not. - Floating-point types: They can represent real values, such as
3.14
or0.01
, with different levels of precision, depending on which of the three floating-point types is used. - Boolean type: The boolean type, known in C++ as
bool
, can only represent one of two states,true
orfalse
.
Here is the complete list of fundamental types in C++:
Group | Type names* | Notes on size / precision |
---|---|---|
Character types | char | Exactly one byte in size. At least 8 bits. |
char16_t | Not smaller than char . At least 16 bits. | |
char32_t | Not smaller than char16_t . At least 32 bits. | |
wchar_t | Can represent the largest supported character set. | |
Integer types (signed) | signed char | Same size as char . At least 8 bits. |
signedshortint | Not smaller than char . At least 16 bits. | |
signedint | Not smaller than short . At least 16 bits. | |
signedlongint | Not smaller than int . At least 32 bits. | |
signedlong longint | Not smaller than long . At least 64 bits. | |
Integer types (unsigned) | unsigned char | (same size as their signed counterparts) |
unsigned shortint | ||
unsignedint | ||
unsigned longint | ||
unsigned long longint | ||
Floating-point types | float | |
double | Precision not less than float | |
long double | Precision not less than double | |
Boolean type | bool | |
Void type | void | no storage |
Null pointer | decltype(nullptr) |
* The names of certain integer types can be abbreviated without their
signed
and int
components - only the part not in italics is required to identify the type, the part in italics is optional. I.e., signed short int
can be abbreviated as signed short
, short int
, or simply short
; they all identify the same fundamental type.Within each of the groups above, the difference between types is only their size (i.e., how much they occupy in memory): the first type in each group is the smallest, and the last is the largest, with each type being at least as large as the one preceding it in the same group. Other than that, the types in a group have the same properties.
Note in the panel above that other than
char
(which has a size of exactly one byte), none of the fundamental types has a standard size specified (but a minimum size, at most). Therefore, the type is not required (and in many cases is not) exactly this minimum size. This does not mean that these types are of an undetermined size, but that there is no standard size across all compilers and machines; each compiler implementation may specify the sizes for these types that fit the best the architecture where the program is going to run. This rather generic size specification for types gives the C++ language a lot of flexibility to be adapted to work optimally in all kinds of platforms, both present and future. Type sizes above are expressed in bits; the more bits a type has, the more distinct values it can represent, but at the same time, also consumes more space in memory:
Size | Unique representable values | Notes |
---|---|---|
8-bit | 256 | = 28 |
16-bit | 65 536 | = 216 |
32-bit | 4 294 967 296 | = 232 (~4 billion) |
64-bit | 18 446 744 073 709 551 616 | = 264 (~18 billion billion) |
For integer types, having more representable values means that the range of values they can represent is greater; for example, a 16-bit unsigned integer would be able to represent 65536 distinct values in the range 0 to 65535, while its signed counterpart would be able to represent, on most cases, values between -32768 and 32767. Note that the range of positive values is approximately halved in signed types compared to unsigned types, due to the fact that one of the 16 bits is used for the sign; this is a relatively modest difference in range, and seldom justifies the use of unsigned types based purely on the range of positive values they can represent.
For floating-point types, the size affects their precision, by having more or less bits for their significant and exponent.
If the size or precision of the type is not a concern, then
char
, int
, and double
are typically selected to represent characters, integers, and floating-point values, respectively. The other types in their respective groups are only used in very particular cases.The properties of fundamental types in a particular system and compiler implementation can be obtained by using the numeric_limits classes (see standard header
'><limits>
). If for some reason, types of specific sizes are needed, the library defines certain fixed-size type aliases in header '><cstdint>
.The types described above (characters, integers, floating-point, and boolean) are collectively known as arithmetic types. But two additional fundamental types exist:
void
, which identifies the lack of type; and the type nullptr
, which is a special type of pointer. Both types will be discussed further in a coming chapter about pointers.C++ supports a wide variety of types based on the fundamental types discussed above; these other types are known as compound data types, and are one of the main strengths of the C++ language. We will also see them in more detail in future chapters.
Declaration of variables
C++ is a strongly-typed language, and requires every variable to be declared with its type before its first use. This informs the compiler the size to reserve in memory for the variable and how to interpret its value. The syntax to declare a new variable in C++ is straightforward: we simply write the type followed by the variable name (i.e., its identifier). For example:These are two valid declarations of variables. The first one declares a variable of type
int
with the identifier a
. The second one declares a variable of type float
with the identifier mynumber
. Once declared, the variables a
and mynumber
can be used within the rest of their scope in the program.If declaring more than one variable of the same type, they can all be declared in a single statement by separating their identifiers with commas. For example:
This declares three variables (
a
, b
and c
), all of them of type int
, and has exactly the same meaning as:To see what variable declarations look like in action within a program, let's have a look at the entire C++ code of the example about your mental memory proposed at the beginning of this chapter:
Don't be worried if something else than the variable declarations themselves look a bit strange to you. Most of it will be explained in more detail in coming chapters.
Initialization of variables
When the variables in the example above are declared, they have an undetermined value until they are assigned a value for the first time. But it is possible for a variable to have a specific value from the moment it is declared. This is called the initialization of the variable.In C++, there are three ways to initialize variables. They are all equivalent and are reminiscent of the evolution of the language over the years:
The first one, known as c-like initialization (because it is inherited from the C language), consists of appending an equal sign followed by the value to which the variable is initialized:
type identifier = initial_value;
For example, to declare a variable of type
int
called x
and initialize it to a value of zero from the same moment it is declared, we can write:A second method, known as constructor initialization (introduced by the C++ language), encloses the initial value between parentheses (
()
):type identifier (initial_value);
For example:
Finally, a third method, known as uniform initialization, similar to the above, but using curly braces (
{}
) instead of parentheses (this was introduced by the revision of the C++ standard, in 2011):type identifier {initial_value};
For example:
All three ways of initializing variables are valid and equivalent in C++.
Tipos De Variables Programacion
Type deduction: auto and decltype
When a new variable is initialized, the compiler can figure out what the type of the variable is automatically by the initializer. For this, it suffices to useauto
as the type specifier for the variable:Here,
bar
is declared as having an auto
type; therefore, the type of bar
is the type of the value used to initialize it: in this case it uses the type of foo
, which is int
.Variables that are not initialized can also make use of type deduction with the
decltype
specifier:Here,
bar
is declared as having the same type as foo
.auto
and decltype
are powerful features recently added to the language. But the type deduction features they introduce are meant to be used either when the type cannot be obtained by other means or when using it improves code readability. The two examples above were likely neither of these use cases. In fact they probably decreased readability, since, when reading the code, one has to search for the type of foo
to actually know the type of bar
.Tipos De Variables Estadisticas
Introduction to strings
Fundamental types represent the most basic types handled by the machines where the code may run. But one of the major strengths of the C++ language is its rich set of compound types, of which the fundamental types are mere building blocks.An example of compound type is the
string
class. Variables of this type are able to store sequences of characters, such as words or sentences. A very useful feature!A first difference with fundamental data types is that in order to declare and use objects (variables) of this type, the program needs to include the header where the type is defined within the standard library (header
<string>
): As you can see in the previous example, strings can be initialized with any valid string literal, just like numerical type variables can be initialized to any valid numerical literal. As with fundamental types, all initialization formats are valid with strings:
Strings can also perform all the other basic operations that fundamental data types can, like being declared without an initial value and change its value during execution:
Note: inserting the
endl
manipulator ends the line (printing a newline character and flushing the stream).The string class is a compound type. As you can see in the example above, compound types are used in the same way as fundamental types: the same syntax is used to declare variables and to initialize them.
For more details on standard C++ strings, see the string class reference.
Tabla De Tipos De Variables En Dev C++
Previous: Structure of a program | Index | Next: Constants |