Está en la página 1de 24

Matrices

Una matriz es una serie de elementos del mismo tipo colocados en ubicaciones de memoria
contiguas a las que se puede hacer referencia individualmente agregando un índice a un
identificador único.

Eso significa que, por ejemplo, cinco valores de tipo int se pueden declarar una matriz sin
tener que declarar 5 variables diferentes (cada una con su propio identificador). En cambio,
utilizando una matriz, los cinco valores int se almacenan en ubicaciones de memoria
contiguas, y se puede acceder a los cinco utilizando el mismo identificador, con el índice
adecuado.

Por ejemplo, una matriz que contiene 5 valores enteros de tipo int llamado foo podría
representarse como:

donde cada panel en blanco representa un elemento de la matriz. En este caso, estos son
valores de tipo int. Estos elementos están numerados del 0 al 4, siendo 0 el primero y 4 el
último; En C ++, el primer elemento de una matriz siempre está numerado con un cero (no
uno), sin importar su longitud.

Al igual que una variable regular, una matriz debe declararse antes de usarse. Una
declaración típica para una matriz en C ++ es: donde es un tipo válido (como , ...), es un
identificador válido y el campo (que siempre está entre corchetes ), especifica la longitud de
la matriz en términos de El número de elementos. Por lo tanto, la matriz, con cinco elementos
de tipo int, puede declararse como:

type name [elements];

typeintfloatnameelements[]

fooint

int foo [5];

NOTA: El campo elements entre corchetes [], que representa el número de elementos en la
matriz, debe ser una expresión constante , ya que las matrices son bloques de memoria
estática cuyo tamaño debe determinarse en tiempo de compilación, antes de que se ejecute el
programa.
Inicializando matrices
Por defecto, las matrices regulares de alcance local (por ejemplo, aquellas declaradas dentro de
una función o bloque) se dejan sin inicializar. Esto significa que ninguno de sus elementos está
configurado para ningún valor en particular; sus contenidos son indeterminados en el punto en
que se declara la matriz.

Pero los elementos en una matriz se pueden inicializar explícitamente a valores específicos cuando
se declara, encerrando esos valores iniciales entre llaves {}. Por ejemplo:

int foo [5] = { 16, 2, 77, 40, 12071 };

Esta declaración declara una matriz que se puede representar así:

El número de valores entre llaves {}no debe ser mayor que la cantidad de elementos en la
matriz. Por ejemplo, en el ejemplo anterior, foo se declaró indicando que tenía 5 elementos
(según lo especificado por el número entre corchetes, []), y las llaves {}contenían exactamente 5
valores, uno para cada elemento. Si se declara con menos, los elementos restantes se establecen
en sus valores predeterminados (que, para los tipos fundamentales(primitivos), significa que están
llenos de ceros). Por ejemplo:

int bar [5] = { 10, 20, 30 };

Creará una matriz como esta:

el inicializador puede incluso no tener valores, solo las llaves:

int baz [5] = { };

Esto crea una matriz de cinco valores int, cada uno inicializado con un valor de cero:

cuando se proporciona una inicialización de valores para una matriz, C++ permite la posibilidad de
dejar los corchetes vacíos []. En este caso, el compilador asumirá automáticamente un tamaño
para la matriz que coincida con el número de valores incluidos entre las llaves {}:

int foo [] = { 16, 2, 77, 40, 12071 };

Después de esta declaración, la matriz foo tendría 5 int de longitud, ya que proporcionamos 5
valores de inicialización.
Finalmente, la evolución de C ++ ha llevado a la adopción de la inicialización universal también
para matrices. Por lo tanto, ya no es necesario el signo igual entre la declaración y el
inicializador. Ambas declaraciones son equivalentes:

1 int foo[] = { 10, 20, 30 };


2 int foo[] { 10, 20, 30 };

Las matrices estáticas, y aquellas declaradas directamente en un espacio de nombres (fuera de


cualquier función), siempre se inicializan. Si no se especifica un inicializador explícito, todos los
elementos se inicializan por defecto (con ceros, para los tipos fundamentales).

Acceder a los valores de una matriz


Se puede acceder a los valores de cualquiera de los elementos en una matriz al igual que el valor
de una variable regular del mismo tipo. La sintaxis es:

name[index]

Siguiendo los ejemplos anteriores en los que foo tenía 5 elementos y cada uno de esos elementos
era de tipo int, el nombre que se puede usar para referirse a cada elemento es el siguiente:

Por ejemplo, la siguiente instrucción almacena el valor 75 en el tercer elemento de foo:

foo [2] = 75;

y, por ejemplo, lo siguiente copia el valor del tercer elemento de fooa una variable llamada x:

x = foo[2];

Por lo tanto, la expresión foo[2]es en sí misma una variable de tipo int.

Observe que foo se especifica el tercer elemento de foo[2], ya que el primero es foo[0], el
segundo es foo[1], y por lo tanto, el tercero es foo[2]. Por esta misma razón, su último
elemento es foo[4]. Por lo tanto, si escribimos foo[5], estaríamos accediendo al sexto
elemento fooy, por lo tanto, en realidad excederíamos el tamaño de la matriz.

En C ++, es sintácticamente correcto exceder el rango válido de índices para una matriz. Esto
puede crear problemas, ya que acceder a elementos fuera del rango no causa errores en la
compilación, pero puede causar errores en el tiempo de ejecución. La razón para que esto se
permita se verá en un capítulo posterior cuando se introducen los punteros.

En este punto, es importante poder distinguir claramente entre los dos usos que los corchetes []
han relacionado con las matrices. Realizan dos tareas diferentes: una es especificar el tamaño de
las matrices cuando se declaran; y el segundo es especificar índices para elementos de matriz
concretos cuando se accede a ellos. No confunda estos dos posibles usos de corchetes []con
matrices.

1 int foo[5]; // declaration of a new array


2 foo[2] = 75; // access to an element of the array.
La principal diferencia es que la declaración está precedida por el tipo de elementos, mientras que
el acceso no.

Algunas otras operaciones válidas con matrices:

1 foo[0] = a;
2 foo[a] = 75;
3 b = foo [a+2];
4 foo[foo[a]] = foo[2] + 5;

Por ejemplo:

// arrays example
#include <iostream>
using namespace std;

int foo [] = {16, 2, 77, 40, 12071};


int n, result=0;

int main ()
{
for ( n=0 ; n<5 ; ++n )
{
result += foo[n];
}
cout << result;
return 0;
}

Matrices multidimensionales

Las matrices multidimensionales se pueden describir como "matrices de matrices". Por ejemplo,
una matriz bidimensional se puede imaginar como una tabla bidimensional hecha de elementos,
todos ellos del mismo tipo de datos uniforme.

Jimmy representa una matriz bidimensional de 3 por 5 elementos de tipo int. La sintaxis de C ++
para esto es:

int jimmy [3][5];

y, por ejemplo, la forma de hacer referencia al segundo elemento verticalmente y al cuarto


horizontalmente en una expresión sería:

jimmy[1][3]
(recuerde que los índices de matriz siempre comienzan con cero).

Las matrices multidimensionales no están limitadas a dos índices (es decir, dos
dimensiones). Pueden contener tantos índices como sea necesario. Aunque tenga cuidado: la
cantidad de memoria necesaria para una matriz aumenta exponencialmente con cada
dimensión. Por ejemplo:

char century [100][365][24][60][60];

declara una matriz con un elemento de tipo char por cada segundo en un siglo. ¡Esto asciende a
más de 3 mil millones char! ¡Entonces esta declaración consumiría más de 3 gigabytes de
memoria!

Al final, las matrices multidimensionales son solo una abstracción para los programadores, ya que
se pueden lograr los mismos resultados con una matriz simple, multiplicando sus índices:

1 int jimmy [3][5]; // is equivalent to


2 int jimmy [15]; // (3 * 5 = 15)

Con la única diferencia con las matrices multidimensionales, el compilador recuerda


automáticamente la profundidad de cada dimensión imaginaria. Las siguientes dos piezas de
código producen exactamente el mismo resultado, pero una usa una matriz bidimensional
mientras que la otra usa una matriz simple:

matriz multidimensional matriz pseudo-multidimensional


#define WIDTH 5 #define WIDTH 5
#define HEIGHT 3 #define HEIGHT 3

int jimmy [HEIGHT][WIDTH]; int jimmy [HEIGHT * WIDTH];


int n,m; int n,m;

int main () int main ()


{ {
for (n=0; n<HEIGHT; n++) for (n=0; n<HEIGHT; n++)
for (m=0; m<WIDTH; m++) for (m=0; m<WIDTH; m++)
{ {
jimmy[n][m]=(n+1)*(m+1); jimmy[n*WIDTH+m]=(n+1)*(m+1);
} }
} }

Ninguno de los dos fragmentos de código anteriores produce ningún resultado en la pantalla, pero
ambos asignan valores al bloque de memoria llamado jimmy de la siguiente manera:
Tenga en cuenta que el código usa constantes definidas para el ancho y la altura, en lugar de usar
directamente sus valores numéricos. Esto le da al código una mejor legibilidad y permite que los
cambios en el código se realicen fácilmente en un solo lugar.

Matrices como parámetros


En algún momento, es posible que necesitemos pasar una matriz a una función como
parámetro. En C ++, no es posible pasar todo el bloque de memoria representado por una matriz
a una función directamente como argumento. Pero lo que se puede pasar es su dirección. En la
práctica, esto tiene casi el mismo efecto, y es una operación mucho más rápida y eficiente.

Para aceptar una matriz como parámetro para una función, los parámetros pueden declararse el
tipo de matriz, pero con corchetes vacíos, omitiendo el tamaño real de la matriz. Por ejemplo:

void procedure (int arg[])

Esta función acepta un parámetro del tipo "matriz de int" llamado arg. Para pasar a esta función
una matriz declarada como:

int myarray [40];

bastaría con escribir una llamada como esta:

procedure (myarray);

Aquí tienes un ejemplo completo:

// arrays as parameters
#include <iostream>
using namespace std;

void printarray (int arg[], int length) {


for (int n=0; n<length; ++n)
cout << arg[n] << ' ';
cout << '\n';
}

int main ()
{
int firstarray[] = {5, 10, 15};
int secondarray[] = {2, 4, 6, 8, 10};
printarray (firstarray,3);
printarray (secondarray,5);
}

En el código anterior, el primer parámetro ( int arg[]) acepta cualquier matriz cuyos
elementos sean de tipo int, independientemente de su longitud. Por esa razón, hemos
incluido un segundo parámetro que le dice a la función la longitud de cada matriz que le
pasamos como primer parámetro. Esto permite que el bucle for que imprime la matriz
conozca el rango para iterar en la matriz pasada, sin salir del rango.
En una declaración de función, también es posible incluir matrices multidimensionales. El
formato para un parámetro de matriz tridimensional es:

base_type[][depth][depth]

Por ejemplo, una función con una matriz multidimensional como argumento podría ser:

void procedure (int myarray[][3][4])

Observe que los primeros corchetes []se dejan vacíos, mientras que los siguientes
especifican tamaños para sus respectivas dimensiones. Esto es necesario para que el
compilador pueda determinar la profundidad de cada dimensión adicional.

En cierto modo, pasar una matriz como argumento siempre pierde una dimensión. La razón
detrás es que, por razones históricas, las matrices no se pueden copiar directamente y, por lo
tanto, lo que realmente se pasa es un puntero. Esta es una fuente común de errores para
programadores novatos. Aunque una comprensión clara de los punteros, explicada en un
próximo capítulo, ayuda mucho.

Librería array
Las matrices explicadas anteriormente se implementan directamente como una característica del
lenguaje, heredada del lenguaje C. Son una gran característica, pero al restringir su copia y
fácilmente decaer en punteros, probablemente sufren un exceso de optimización.

Para superar algunos de estos problemas con las matrices incorporadas en el lenguaje, C ++
proporciona un tipo de matriz alternativa como contenedor estándar. Es una plantilla de tipo (una
plantilla de clase, de hecho) definida en el encabezado <array>.

Los contenedores son una característica de la biblioteca que queda fuera del alcance de este
tutorial y, por lo tanto, la clase no se explicará en detalle aquí. Baste decir que operan de manera
similar a las matrices incorporadas, excepto que permiten la copia (una operación realmente
costosa que copia todo el bloque de memoria y, por lo tanto, se usa con cuidado) y se
descomponen en punteros solo cuando explícitamente se le dice que lo haga (por medio de su
miembro data).

Solo como ejemplo, estas son dos versiones del mismo ejemplo que utilizan la matriz incorporada
en el lenguaje descrita en este capítulo y el contenedor en la biblioteca:

conjunto de idiomas incorporado matriz de biblioteca de contenedores


#include <iostream> #include <iostream>
#include <array>
using namespace std; using namespace std;

int main() int main()


{ {
int myarray[3] = {10,20,30}; array<int,3> myarray {10,20,30};

for (int i=0; i<3; ++i) for (int i=0; i<myarray.size(); ++i)
++myarray[i]; ++myarray[i];

for (int elem : myarray) for (int elem : myarray)


cout << elem << '\n'; cout << elem << '\n';
} }
Secuencias de caracteres
La clase string se introdujo anteriormente. Es una clase para manejar y manipular cadenas de
caracteres. Sin embargo, debido a que las cadenas son, de hecho, secuencias de caracteres,
podemos representarlas también como matrices simples de elementos de un tipo de carácter.

Por ejemplo, la siguiente matriz:

char foo [20];

es una matriz que puede almacenar hasta 20 elementos de tipo char. Se puede representar como:

Por lo tanto, esta matriz tiene la capacidad de almacenar secuencias de hasta 20 caracteres. Pero
esta capacidad no necesita agotarse por completo: la matriz también puede acomodar secuencias
más cortas. Por ejemplo, en algún punto de un programa, la secuencia "Hello" o la
secuencia "Merry Christmas" se pueden almacenar foo, ya que ambas encajarían en una
secuencia con capacidad para 20 caracteres.

Por convención, el final de las cadenas representadas en secuencias de caracteres se señala


mediante un carácter especial: el carácter nulo , cuyo valor literal se puede escribir
como '\0'(barra diagonal inversa, cero).

En este caso, la matriz de 20 elementos de tipo char llamada foo se puede representar
almacenando las secuencias de caracteres "Hello" y "Merry Christmas" como:

Observe cómo después del contenido de la cadena en sí, '\0'se ha agregado un carácter nulo ( )
para indicar el final de la secuencia. Los paneles en color gris representan char elementos con
valores indeterminados.

Inicialización de secuencias de caracteres terminadas en nulo


Debido a que las matrices de caracteres son matrices ordinarias, siguen las mismas reglas que
estas. Por ejemplo, para inicializar una matriz de caracteres con una secuencia predeterminada de
caracteres, podemos hacerlo como cualquier otra matriz:

char myword[] = { 'H', 'e', 'l', 'l', 'o', '\0' };

Lo anterior declara una matriz de 6 elementos de tipo char inicializados con los caracteres que
forman la palabra "Hello" más un carácter nulo '\0' al final.

Pero las matrices de elementos de caracteres tienen otra forma de inicializarse: usar literales de
cadena directamente.
En las expresiones utilizadas en algunos ejemplos en capítulos anteriores, los literales de cadena
ya han aparecido varias veces. Estos se especifican encerrando el texto entre comillas dobles
( "). Por ejemplo:

"the result is: "

Este es un literal de cadena, probablemente usado en algún ejemplo anterior.

Las secuencias de caracteres entre comillas dobles ( ") son constantes literales . Y su tipo es, de
hecho, una matriz de caracteres con terminación nula. Esto significa que los literales de cadena
siempre tienen un carácter nulo ('\0') agregado automáticamente al final.

Por lo tanto, la matriz de elementos char llamados myword puede inicializarse con una secuencia
de caracteres terminada en nulo por cualquiera de estas dos declaraciones:

1 char myword[] = { 'H', 'e', 'l', 'l', 'o', '\0' };


2 char myword[] = "Hello";

En ambos casos, la matriz de caracteres myword se declara con un tamaño de 6 elementos de


tipo char: los 5 caracteres que componen la palabra "Hello", más un carácter nulo final ( '\0'),
que especifica el final de la secuencia y que, en el segundo caso, cuando se usan comillas dobles
( ") se agrega automáticamente.

Tenga en cuenta que aquí estamos hablando de inicializar una matriz de caracteres en el momento
en que se declara, y no de asignarles valores más tarde (una vez que ya se han declarado). De
hecho, debido a que los literales de cadena son matrices regulares, tienen las mismas restricciones
que estos y no se les pueden asignar valores.

Expresiones (una vez que myword ya se ha declarado como arriba), como:

1 myword = "Bye";
2 myword[] = "Bye";

que no sea válido, como tampoco sería la siguiente:

myword = {'B', 'y', 'e', '\0' };

Esto se debe a que a las matrices no se les pueden asignar valores. Sin embargo, tenga en cuenta
que a cada uno de sus elementos se le puede asignar un valor individualmente. Por ejemplo, esto
sería correcto:

1 myword[0] = 'B';
2 myword[1] = 'y';
3 myword[2] = 'e';
4 myword[3] = '\0';
Cadenas y secuencias de caracteres con terminación nula
Las matrices simples con secuencias de caracteres terminadas en nulo son los tipos típicos
utilizados en el lenguaje C para representar cadenas (es por eso que también se conocen
como cadenas C ). En C ++, aunque la biblioteca estándar define un tipo específico para cadenas
(clase string), aún así, las matrices simples con secuencias de caracteres terminadas en nulo
(cadenas C) son una forma natural de representar cadenas en el lenguaje; de hecho, los literales
de cadena todavía siempre producen secuencias de caracteres con terminación nula, y no string
objetos.

En la biblioteca estándar, ambas representaciones para cadenas (cadenas C y cadenas de


biblioteca) coexisten, y la mayoría de las funciones que requieren cadenas se sobrecargan para
admitir ambas.

Por ejemplo, cin y cout admite secuencias terminadas en nulo directamente, lo que permite
extraerlas directamente cin o insertarlas cout, al igual que las cadenas. Por ejemplo:
// strings and NTCS:
#include <iostream>
#include <string>
using namespace std;

int main ()
{
char question1[] = "What is your name? ";
string question2 = "Where do you live? ";
char answer1 [80];
string answer2;
cout << question1;
cin >> answer1;
cout << question2;
cin >> answer2;
cout << "Hello, " << answer1;
cout << " from " << answer2 << "!\n";
return 0;
}

En este ejemplo, se utilizan ambas matrices de caracteres que utilizan secuencias y cadenas
terminadas en nulo. Son bastante intercambiables en su uso junto con cin y cout, pero hay una
diferencia notable en sus declaraciones: las matrices tienen un tamaño fijo que debe especificarse
implícita o explícitamente cuando se declara; question1 tiene un tamaño exacto de 20 caracteres
(incluidos los caracteres nulos finales) y answer1 tiene un tamaño de 80 caracteres; mientras que
las cadenas son simplemente cadenas, no se especifica ningún tamaño. Esto se debe al hecho de
que las cadenas tienen un tamaño dinámico determinado durante el tiempo de ejecución, mientras
que el tamaño de las matrices se determina en la compilación, antes de que se ejecute el
programa.

En cualquier caso, las secuencias y cadenas de caracteres con terminación nula se transforman
fácilmente entre sí:

Las secuencias de caracteres con terminación nula pueden transformarse en cadenas


implícitamente, y las cadenas pueden transformarse en secuencias de caracteres con terminación
nula mediante el uso de cualquiera de string las funciones miembro c_stro data:

1 char myntcs[] = "some text";


2 string mystring = myntcs; // convert c-string to string
3 cout << mystring; // printed as a library string
4 cout << mystring.c_str(); // printed as a c-string

(nota: ambos c_str y los data miembros de string son equivalentes)


plantilla de clase

std :: array
template <class T, size_t N>;

T : Tipo de dato
N : Cantidad de elementos

Clase array ( Disponible a partir la versión 11 de c++ )

Compilar empleando la librería array : g++ -std=c++11 prgFuente.c++ -o prgEjecutable.exe

La librería array nos permite crear arreglos de forma mas simple, dispone de un conjunto de
funciones propias (métodos) que nos permiten manipular el arreglo.

Para crear un arreglo empleando array en nuestro programa debemos incluir la librería.

Ejemplo crea un arreglo de cinco (5) elementos numéricos tipo entero;

#include <array>
int main()
{
std::array<int, 5> miArreglo;
return 0;
}
Nota:
La librería array contiene todo bajo el espacio de trabajo std;

Para acceder a los elementos del ejemplo anterior podemos hacerlo


1. Empleando [ ], como lo hicimos con los arreglos normales.
2. Empleando la función miembro at;

Empleando []
#include <iostream>
#include <array>
int main()
{
std::array<int, 5> miArreglo;
miArreglo.fill(3); //- Asigna el valor 3 a cada posición del array miArreglo.

for(int i=0; i<miArreglo.length(); ++i ) //- miArreglo.length() : Retorna la cantidad


//elemetos contenidos en la colección;
{
std::cout <<” ”<< miArreglo[i];
}

return 0;
}
Empleando at()
#include <iostream>
#include <array>
int main()
{
std::array<int, 5> miArreglo;
miArreglo.fill(3);

for(int i=0; i<miArreglo.length(); ++I )


{
std::cout <<” ”<< miArreglo.at(i);
}

return 0;
}

Algunas funciones miembros del array:


begin Retorna un iterador al principio de la colección
end Retorna un iterador al principio de la colección
rbegin Retorna un iterador al reverse begin reverse
rend Retorna un iterador al reverse end reverse
at Permite acceder a un elemento colocando entre () la pos del
elemento acceder.
front Retorna una referencia al primer elemento
back Retorna una referencia al último elemento
fill Emplada para asignar un valor a todas las pos del arreglo
size Retorna la cantidad de elementos contenidos en el arreglo
max_size Al igual que size retorna la cantidad de elementos del arreglo
empty Retorna un bool que indica si el arreglo esta vacio ( size() == 0 )
Ejemplo
//- Lee las edades de 10 personas, las almacena en un array y
//- Luego muestra el contenido del arreglo ( las edades ) en la consola
//-
//- Para compilar : g++ -std=c++11 prgFuente.c++ -o prgEjecutable.exe
//-
#include <iostream>
#include <array>

using namespace std;

int main()
{
array<int, 10> edad;

//- Asigna 0 a cada pos del arreglo


edad.fill(0);

//- Accediendo a los elementos del arreglo con []


for ( int i=0; i <= edad.size(); i++)
{
cout << "Introducir edad (" << i << ") : " << edad[i] << endl;
}

//- Mostrando la cantidad de elementos array


cout << "La cantidad de elementos del array es : " << edad.size() << endl;

//- Asignado valores a los elementos del arreglo con at()


for ( int i=0; i < edad.size(); i++)
{
cout << "Introducir edad (" << i << ") : ";
cin >> edad.at(i);
}

cout << endl;

cout << " Recorriendo los elementos del arreglo con [] " << endl;
for ( int i=0; i < edad.size(); i++)
{
cout << " edad (" << i << ") : " << edad[i] << endl;
}

cout << " Recorriendo los elementos del arreglo empleando iterador " << endl;
for ( auto it = edad.begin(); it != edad.end(); it++)
{
cout << " edad : " << *it << endl;
}

cout << " Recorriendo los elementos del arreglo en orden inverso, empleando iteradores " << endl;
for ( auto it = edad.rbegin(); it != edad.rend(); it++)
{
cout << " edad : " << *it << endl;
}

cout << "Mostrando la primera esad empleando front " << endl;
cout << edad.front() << endl;

cout << "Mostrando la ultima edad empleando back " << endl;
cout << edad.back() << endl;

return 0;
}
Otro tipo de colección son los vectores

La librería <vector> se emplea para manejar arreglos o colecciones de elementos de un mismo tipo de
forma dinámica. La ventaja del vector con relación a los tipos <array> o a los arreglos estilo c es
Son colecciones dinámicas que pueden expandirse o contraer de forma dinámica.
Dispone de un conjunto de funciones propias (métodos) que nos permiten manipular los
elementos del vector.

Sintaxis:
default (1) explicit vector (const allocator_type& alloc = allocator_type());
explicit vector (size_type n, const value_type& val = value_type(),
fill (2) const allocator_type& alloc = allocator_type());
template <class InputIterator>
range (3) vector (InputIterator first, InputIterator last,
const allocator_type& alloc = allocator_type());
copy (4) vector (const vector& x);

(1) constructor de colección vacío (constructor predeterminado)


Construye un contenedor vacío , sin elementos.
(2) constructor de relleno
Construye una colección con n elementos. Cada elemento es una copia de val.
(3) constructor de rango
Construye una colección con tantos elementos como el rango [primero, último), con cada
elemento construido a partir de su elemento correspondiente en ese rango, en el mismo
orden.
(4) constructor de copia
Construye una colección con una copia de cada uno de los elementos en x, en el mismo
orden.
La colección mantiene una copia interna de alloc , que se utiliza para asignar
almacenamiento durante toda su vida útil.

El constructor de copias (4) crea una colección que guarda y usa una copia
del asignador de x.

Parámetros
alloc

Asignador de objeto.
El contenedor conserva y utiliza una copia interna de este asignador.
El tipo de miembro allocator_type es el tipo de asignador interno utilizado por el contenedor, definido
en vector como un alias de su segundo parámetro de plantilla ( Alloc ).
Si allocator_type es una instancia del asignador predeterminado (que no tiene estado), esto no es relevante.

n
Tamaño inicial del contenedor (es decir, el número de elementos en el contenedor en la construcción).
El tipo de miembro size_type es un tipo integral sin signo.

val
Valor para llenar el contenedor. Cada uno de los n elementos en el contenedor se inicializará en una copia de este valor.
Tipo de miembro value_type es el tipo de elementos en el contenedor, definido en vector como un alias de su primer
parámetro de plantilla ( T ).

primero último
Ingrese iteradores a las posiciones inicial y final en un rango. El rango utilizado es [first, last) , que incluye todos los
elementos entre first y last , incluido el elemento señalado por first pero no el elemento señalado por last .
El argumento de plantilla de función InputIterator será un tipo de iterador de entrada que apunta a elementos de un tipo
a partir del cual se pueden construir objetos value_type .

X
Otro objeto vectorial del mismo tipo (con los mismos argumentos de plantilla de clase T y Alloc ), cuyo contenido se copia o
se adquiere.

il
Un objeto initializer_list .
Estos objetos se construyen automáticamente a partir de los declaradores de la lista de inicializadores .
Tipo de miembro value_type es el tipo de elementos en el contenedor, definido en vector como un alias de su primer
parámetro de plantilla ( T ).

Algunas funciones miembros del vector:


begin Retorna un iterador al principio de la colección
end Retorna un iterador al principio de la colección
rbegin Retorna un iterador al reverse begin reverse
rend Retorna un iterador al reverse end reverse
at Permite acceder a un elemento colocando entre () la pos del
elemento acceder.
front Retorna una referencia al primer elemento
back Retorna una referencia al último elemento
assign Asigna nuevos contenidos al vector, reemplazando sus
contenidos actuales y modificando su tamaño como consecia.
size Retorna la cantidad de elementos contenidos en el arreglo
max_size Al igual que size retorna la cantidad de elementos del arreglo
empty Retorna un bool que indica si el vector esta vacío ( size() == 0 )
push_back Agrega un nuevo elemento al final del vector, después de su
último elemento.

Esto aumenta efectivamente el tamaño del vector en uno, lo


que provoca una reasignación automática del espacio de
almacenamiento asignado si, y solo si, el nuevo tamaño
del vector supera la capacidad de actual del mismo.
popo_back Elimina el último elemento en el vector, reduciendo el tamaño
de este en uno.

Esto destruye el elemento eliminado.


operador[] Devuelve una referencia al elemento en la posición n en
el contenedor del vector.

La función miembro at, vector :: at , tiene el mismo


comportamiento que esta función de operador, excepto
que vector :: at se comprueba y señala si la posición solicitada
está fuera de rango lanzando una excepción out_of_range .

Los programas nunca deberían llamar a esta función con un


argumento n que esté fuera de rango , ya que esto causa un
comportamiento indefinido .
erase Elimina del vector un solo elemento ( posición ) o un rango de
elementos ( [primero, último) ).

Esto reduce el tamaño del vector en la cantidad de elementos


eliminados, los mismos se destruyen ( dejan de ocupar espacio
en memoria ).

Debido a que los vectores usan una matriz como su


almacenamiento subyacente, el borrado de elementos en
posiciones distintas al extremo del vector hace que el
contenedor reubique todos los elementos después de que el
segmento se borre a sus nuevas posiciones. Esta es
generalmente una operación ineficiente en comparación con la
realizada para la misma operación por otros tipos de
estructuras de colecciones (como list o forward_list ).
clear Elimina todos los elementos del vector ( estos se destruyen),
dejando el contenedor con un tamaño de 0 .
Operador= Asigna nuevos contenidos al contenedor, reemplazando sus
contenidos actuales y modificando el tamaño de este.
Ejemplo.

// constructing vectors
#include <iostream>
#include <vector>

int main ()
{
// constructors used in the same order as described above:
std::vector<int> primero; // vector vacio de enteros
std::vector<int> segundo (4,100); // vector de 4 enteros con valor de 1000 cada elemento
std::vector<int> tercero (segundo.begin(),segundo.end()); // itetando el segundo vector
std::vector<int> cuarto (tercero); // una copia del vector tercero

// El constructor con iterador puede ser empleado a partir de un arreglo.


int lstEnteros[] = {16,2,77,29};
std::vector<int> quinto (lstEnteros, lstEnteros + sizeof(lstEnteros) / sizeof(int) );

std::cout << "The contents of fifth are:";

for (std::vector<int>::iterator it = quinto.begin(); it != quinto.end(); ++it)


std::cout << ' ' << *it;

std::cout << '\n';

return 0;
}

Ejemplos de las funciones miembros.

.->begin(), end(), push_back(), pop_back(), rbegin(), rend(), empty() ,back(), clear(), y []

#include <iostream>
#include <vector>

using namespace std;

int main ()
{
std::vector<int> miVector;

//- Asigna valores al vector empleando push_back


for (int i=1; i<=5; i++) {
miVector.push_back(i*3); //- Añade un elemento al final del vector
}

std::cout << "El vector contiene :";

//- Recorriendo el vector con un iterador


cout << endl
<< "Mostrando los valores del vector "
<< endl;
for (std::vector<int>::iterator it = miVector.begin() ; it != miVector.end(); ++it)
{
std::cout << ' ' << *it;
}

cout << endl


<< "Mostrando los valores del vector en orden inverso"
<< endl;
//- Recorriendo el vector con iterador reverso
for (std::vector<int>::reverse_iterator it = miVector.rbegin() ; it != miVector.rend(); ++it)
{
std::cout << ' ' << *it;
}

cout << endl;

//- Eliminando los valores del vector uno a uno empleando pop_back()
while( !miVector.empty() )
{

int valItem = miVector.back();


cout << "Size del vector antes de elimiar ultimo elemento = " << miVector.size();
miVector.pop_back();
cout << " Luego de eliminado = " << miVector.size()
<< " valor eliminado = " << valItem
<< endl;
}

std::cout << '\n';

//- Asigna nuevos valores al vector empleando push_back


for (int i=1; i<=10; i++) {
miVector.push_back((i+2)*3); //- Añade un elemento al final del vector
}

cout << endl


<< "Mostrando los valores del vector epleando []"
<< endl;
//- Recorriendo el vector empleando []
for (int i = 0; i < miVector.size() ; ++i )
{
std::cout << ' ' << miVector[i];
}

cout << endl


<< "Size del vector antes de ejecutar clear = " << miVector.size()
<< endl;

miVector.clear();

cout << endl


<< " Luego de ejecutar clear = " << miVector.size()
<< endl;

return 0;
}
Ejemplo programa completo ( Usando vector )

//- Registro de nombre personas


//- El programa deberá
//- Registrar nombre persona
//- Modificar nombre persona
//- Eliminar nombre persona
//- Listar nombres

/*
Requisitos
---------------------------
1) Solo se admiten nombres con más de 2 caracteres de longitud
2) Un mismo nombre solo puede estar registrado una sola valores
3) No puede modificar un nombre que no exista en la lista de nombres registrados
4) No puede eliminar un nombre que no exista en la lista de nombres registrados

*/

#include <iostream>
#include <string>
#include <vector>

using namespace std;

int main()
{
vector<string> lstNombres;
vector<string>::iterator it;
string nombre;
string nombreModificar;
bool existe;
int opcion;

do {

cout << endl


<< "Registro nombres personas..." << endl << endl
<< "1 - Registro " << endl
<< "2 - Modificar " << endl
<< "3 - Eliminar " << endl
<< "4 - Listar nombres " << endl
<< endl
<< "9 - Salir " << endl
<< endl
<< "Digitar número opción : ";
cin >> opcion;

//- Para eliminar el carácter enter


cin.ignore();

switch( opcion )
{
case 1 : cout << endl
<< "Introducir nombre a registrar : ";
getline(cin, nombre);

if ( nombre.length() > 2 )
{
for ( it = lstNombres.begin(); it != lstNombres.end(); ++it )
{
if ( (*it) == nombre )
break;
}

if ( it < lstNombres.end() )
{
cout << endl
<< "No puede registrar el mismo nombre más de una vez"
<< endl;
continue;
}
}
else
{
cout << endl
<< "Nombre invalido"
<< endl;
continue;
}

lstNombres.push_back(nombre);

break;

case 2 : cout << endl


<< "Introducir nombre a modificar: ";
getline(cin, nombreModificar);
cout << endl
<< "Introducir nombre corregido: ";
getline(cin, nombre);

if ( nombre.length() < 3 ) {
cout << endl
<< "Nombre invalido"
<< endl;
continue;
}

//- Buscar nombre modificado


for ( it = lstNombres.begin(); it != lstNombres.end(); ++it )
{
if ( (*it) == nombre )
break;
}

if ( it < lstNombres.end() )
{
cout << endl
<< "No puede registrar el mismo nombre más de una vez"
<< endl;
continue;
}

//- Buscar nombre a modificar en la lista de nombres


for ( it = lstNombres.begin(); it != lstNombres.end(); ++it )
{
if ( (*it) == nombreModificar )
break;
}

if ( it >= lstNombres.end() )
{
cout << endl
<< "El nombre a midificar no existe en la lista"
<< endl;
continue;
}

*it = nombre;

break;

case 3 : cout << endl


<< "Introducir nombre a eliminar: ";
getline(cin, nombre);

//- Buscar nombre a eliminar de la lista


for ( it = lstNombres.begin(); it != lstNombres.end(); ++it )
{
if ( (*it) == nombre )
break;
}
if ( it >= lstNombres.end() )
{
cout << endl
<< "El nombre a eliminar no existe en la lista"
<< endl;
continue;
}

lstNombres.erase(it);

break;
case 4 :
cout << endl
<< "Lista de nombres registrados"
<< endl;
for ( it = lstNombres.begin(); it != lstNombres.end(); ++it )
cout << *it << endl;

break;

case 9 : cout << endl


<< "Fin ejecución programa…"
<< endl;
break;

default : cout << "\nOpcion invalida.....\n";


}

} while ( opcion != 9 );

return 0;
}
Ejemplo multiplicación de matrices (Declaración estática).
/*

Programa que crea dos matrices


asigna valores de forma aleatoria
y calcula el producto entre ambas
matrices, como resultado o salida
el programa muestra la matriz producto

El programa se creará creado matrices estáticas

*/

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

int main()
{
//- Oden Matriz A
unsigned int cantFilasMatrizA;
unsigned int cantColumnasMatrizA;

//- Oden Matriz B


unsigned int cantFilasMatrizB;
unsigned int cantColumnasMatrizB;

cout << endl


<< "Producto Matricial..."
<< endl;

//- Aceptar la cantFilasMatrizA


do {
cout << "Introdcir la cantidad de filas de la Matriz A .: ";
cin >> cantFilasMatrizA;
} while( cantFilasMatrizA < 1 );

//- Aceptar la cantColumnasMatrizA


do {
cout << "Introdcir la cantidad de columnas de la Matriz A .: ";
cin >> cantColumnasMatrizA;
} while( cantColumnasMatrizA < 1 );

cout << endl;

//- Aceptar la cantFilasMatrizB


do {
cout << "Introducir la cantidad de filas de la Matriz B .: ";
cin >> cantFilasMatrizB;
} while( cantFilasMatrizB < 1 );

//- Aceptar la cantColumnasMatrizB


do {
cout << "Introducir la cantidad de columnas de la Matriz B .: ";
cin >> cantColumnasMatrizB;
} while( cantColumnasMatrizB < 1 );

//- Las matrices se podran multiplicar solo si


//- la cantColumnasMatrizA es igual a la cantFilasMatrizB
if ( cantColumnasMatrizA != cantFilasMatrizB )
{
cout << endl
<< "No existe la matriz producto para los órdenes introducidos!!! "
<< endl;
return 0; //- El programa termina;
}

//- Declarando las matrices A, B y R <- Matriz Resultante o producto


int matA[cantFilasMatrizA][cantColumnasMatrizA];
int matB[cantFilasMatrizB][cantColumnasMatrizB];
int matR[cantFilasMatrizA][cantColumnasMatrizB];

//- asignación dinámica de los valores de las matrices A y B


srand(time(NULL));
//--------------------------------------------------------

//- Asignando valores a la matriz A


//---------------------------------
for( int i = 0; i < cantFilasMatrizA; ++i )
{
for( int j = 0; j < cantColumnasMatrizA; ++j )
{
matA[i][j] = rand() % 10 + 1;
}
}

//- Asignando valores a la matriz B


//---------------------------------
for( int i = 0; i < cantFilasMatrizB; ++i )
{
for( int j = 0; j < cantColumnasMatrizB; ++j )
{
matB[i][j] = rand() % 10 + 1;
}
}

//- Multiplicando las matrices A X B


//----------------------------------
for( int i = 0; i < cantFilasMatrizA; ++i )
{
for ( int j = 0; j < cantColumnasMatrizB; ++j )
{

matR[i][j] = 0;

for( int k = 0; k < cantFilasMatrizB; ++k )


{
matR[i][j] += matA[i][k] * matB[k][j];
}

}
}

//- Mostrando los valores de la matriz A


//--------------------------------------
cout << endl << endl
<< "Valores matriz A ...";

for( int i = 0; i < cantFilasMatrizA; ++i )


{
cout << endl;
for( int j = 0; j < cantColumnasMatrizA; ++j )
{
cout << matA[i][j] << '\t';
}
}

//- Mostrando los valores de la matriz B


//---------------------------------------
cout << endl << endl
<< "Valores matriz B ...";
for( int i = 0; i < cantFilasMatrizB; ++i )
{
cout << endl;
for( int j = 0; j < cantColumnasMatrizB; ++j )
{
cout << matB[i][j] << '\t';
}
}

//- Mostrando los valores de la matriz R (Matriz producto)


//--------------------------------------
cout << endl << endl
<< "Valores matriz R (matriz producto) ...";

for( int i = 0; i < cantFilasMatrizA; ++i )


{
cout << endl;
for( int j = 0; j < cantColumnasMatrizB; ++j )
{
cout << matR[i][j] << '\t';
}
}

cout << endl << endl;

return 0;
}
Practica
1. Hacer programa que acepte como entrada el orden de una matriz y
a. Declarare de forma dinámica una matriz cuadrada con el orden introducido
b. Acepte los valore de la matriz
c. Como salida el programa deberá mostrar
i. La sumatoria de:
1. Los elementos que se encuentran en la diagonal principal.
2. Los elementos que están sobre la diagonal principal
3. Los elementos que están bajo la diagonal principal
4. Los elementos que están en la diagonal secundaria
5. Los elementos que están sobre la diagonal secundaria
6. Los elementos que están bajo la diagonal secundaria

2. Hacer programa que lea los órdenes (cant Filas y cant Columnas) de dos matrices, el programa deberá determinar si los
ordenes de las matrices son conformes para la suma, en caso de serlo el programa deberá
a. Aceptar como entrada los valores de ambas matrices
b. Informar como salida la matriz suma y
c. La matriz diferencia

3. Hacer programa que lea las edades de un conjunto de N personas, el programa deberá
a. Ordenar las edades en orden ascendente
b. Mostrar las edades después de ordenadas.

4. Una empresa dedicada a la fabricación de prendas de vestir tiene en su computador un vector con todos los códigos de los
productos que fabrican, la empresa lo contrato a usted porque el vector donde tiene los códigos de los productos que fabrican
existen códigos que se repiten y otros no, su trabajo consiste en crear otro vector a partir del existen sin que se repitan dichos
códigos.