EVA-2

<Numérico>

Operaciones numéricas generalizadas



Esta cabecera se describe un conjunto de algoritmos para realizar ciertas operaciones en las secuencias de valores numéricos. Debido a su flexibilidad, también se pueden adaptar para otros tipos de secuencias.

1.- std :: acumulan

suma (1)
template <class InputIterator, Clase T>
   T acumulan (Primero InputIterator, InputIterator Pasado, T init);
personalizado (2)
template <class InputIterator, el clase T, el clase BinaryOperation>
   T acumulan (Primero InputIterator, InputIterator Pasado, T init,
                 BinaryOperation op_binario);
Acumular valores en rango



Devuelve el resultado de la acumulación de todos los valores en el rango  [primero, último)  a  init . La operación predeterminada es agregar los elementos, pero una operación diferente se puede especificar como  op_binario . El comportamiento de esta plantilla de función es equivalente a:




1
2
3
4
5
6
7
8
9
Plantilla < Clase InputIterator, Clase T>
   T acumulan (Primero InputIterator, InputIterator Pasado, T init)
{
  mientras que (primero! = pasado) {
    init init = + * primero;   // o: init = op_binario (init, * primero) para la versión op_binario
    ++ Primero;
  }
  volver init;
}




Parámetros

primero, último
Iteradores de entrada  a las posiciones inicial y final de una secuencia. El rango utilizado es  [primero, último) , que contiene todos los elementos entre  la primera  y  la última , incluyendo el elemento apuntado por  primera  pero no el elemento apuntado por  último .
init
Valor inicial para el acumulador.
op_binario
Operación binaria teniendo un elemento de tipo T como primer argumento y un elemento en el rango como segundo, y que devuelve un valor que se puede asignar para escribir T.
Esto puede ser o bien un puntero de función o un objeto de función.
La operación no modificará los elementos pasados ​​como sus argumentos.




Valor de retorno

El resultado de la acumulación de  init  y todos los elementos en el rango  [primero, último) .




Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
EJEMPLO // acumulan 
# include <iostream>       // std :: cout 
# include <funcionalmente>     // std :: minus 
# include <Numérica>        // std :: acumulan

int mifuncion ( int x, int y) { volver x + 2 * y;}
  struct MiClase {
   int  Operador () ( int x, int y) { retorno x + 3 * y;}
} MiObjeto;

int main () {
    int init = 100;
    int Números [] = {10,20,30};

  std :: cout << "utilizando acumulan por defecto:" ;
  std :: cout << std :: acumulan (números, 3 +, init);
  std :: cout << "\ n" ;

  std :: cout << "utilizando menos del funcional:" ;
  std :: cout << std :: acumulan (números, números + 3, init, std :: minus < int > ());
  std :: cout << "\ n" ;

  std :: cout << "el uso de la función personalizada:" ;
  std :: cout << std :: acumulan (números, números + 3, init myFunction);
  std :: cout << "\ n" ;

  std :: cout << "el uso de objeto personalizado:" ;
  std :: cout << std :: acumulan (números, números + 3, init, MiObjeto);
  std :: cout << "\ n" ;

  devolver 0;
}


Salida:

utilizando acumulan por defecto: 160
utilizando menos del funcional: 40
con la función Personal: 220
utilizando objetos personalizados: 280

2.- std :: adjacent_difference

diferencia (1)
template <class InputIterator, el clase OutputIterator>
   OutputIterator adjacent_difference (Primero InputIterator, InputIterator Pasado,
                                       RESULTADO OutputIterator);
personalizado (2)
template <class InputIterator, el clase OutputIterator, el clase BinaryOperation>
   OutputIterator adjacent_difference (Primero InputIterator, InputIterator Pasado,
                                        RESULTADO OutputIterator, BinaryOperation op_binario);
Calcule la diferencia adyacente de rango


Asigna a cada elemento en el rango que comienza en  consecuencia  la diferencia entre su elemento correspondiente en el rango  [primero, último)  y el que le precede (a excepción de  resultado * , que se asigna  primero * ). Si  x  representa un elemento en  [primero , último)  y  y  representa un elemento de  resultado , el  y s se puede calcular como: y 0  = x 0 y 1  x = 1  - x 0 y 2  = x 2  - x 1 y 3  = x 3  - x 2 y 4  = x 4  - x 3 ... ... ... La operación predeterminada es calcular la diferencia, pero alguna otra operación se puede especificar como  op_binario lugar. El comportamiento de esta plantilla de función es equivalente a:











1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Plantilla < Clase InputIterator, el clase OutputIterator>
   OutputIterator adjacent_difference (Primero InputIterator, InputIterator Pasado,
                                       OutputIterator RESULTADO)
{
  si (! = Ultimo Primera) {
      TYPENAME iterator_traits <InputIterator> :: hrs value_type antes;
    * Result = prev = * en primer lugar;
    mientras que (++ primero! = pasado) {
      val = * en primer lugar;
      *++result = val - prev;  // or: *++result = binary_op(val,prev)
      prev = val;
    }
    ++ Resultado;
  }
  volver resultado;
}


Parámetros

primero, último
Iteradores de entrada  a las posiciones inicial y final de una secuencia. El rango utilizado es  [primero, último) , que contiene todos los elementos entre  la primera  y  la última , incluyendo el elemento apuntado por  primera  pero no el elemento apuntado por  último .
resultado
Iterador de salida  a la posición inicial en la secuencia de destino donde se almacenan las diferencias. La gama comienza a  resultado  y deberá tener un tamaño lo suficientemente grande como para contener tantos elementos como el intervalo anterior ( [primero, último) ).
op_binario
Operación binaria tomando como argumentos los elementos que tipo de señalado InputIterator, Y devolver el resultado de la sustitución de la operación de diferencia.
Esto puede ser o bien un puntero de función o un objeto de función.


Valor de retorno

Un iterador que señala a pasado el último elemento de la secuencia de destino en el que se han almacenado los elementos resultantes.


Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// EJEMPLO adjacent_difference 
# include <iostream>       // std :: cout 
# include <funcional>     // std :: multiplica 
# include <Numérico>        // std :: adjacent_difference

int myop ( int x, int y) { retorno x + y;}

int main () {
    int val [] = {} 1,2,3,5,9,11,12;
    int RESULTADO [7];

  std :: adjacent_difference (val, val + 7, resultado);
  std :: cout << "adjacent_difference usando por defecto" ,
    para ( int i = 0; i <7; ++ i) std :: cout << resultado [i] << '' ;
  std :: cout << "\ n" ;

  std :: adjacent_difference (val, val + 7, resultado, std :: multiplica < int > ());
  std :: cout << "se multiplica utilizando operación funcional" ,
    para ( int i = 0; i <7; ++ i) std :: cout << resultado [i] << '' ;
  std :: cout << "\ n" ;

  std :: adjacent_difference (val, val + 7, resultado, myop);
  std :: cout << "el uso de la función personalizada:" ;
   para ( int i = 0; i <7; i ++) std :: cout << resultado [i] << '' ;
  std :: cout << "\ n ' ;
    retorno 0;
}


Salida:

utilizando adjacent_difference defecto: 1 1 1 2 4 2 1
utilizando operación funcional multiplica: 1 2 6 15 45 99 132
utilizando la función personalizada: 1 3 5 8 14 20 23

3.- std :: inner_product

suma / multiplicación (1)
template <class InputIterator1, el clase InputIterator2, Clase T>
   T inner_product (InputIterator1 first1, InputIterator1 last1,
                    Primero2 InputIterator2, T init);
personalizado (2)
template <class InputIterator1, el clase InputIterator2, el clase T,
          BinaryOperation1 Clase, Clase BinaryOperation2>
   T inner_product (InputIterator1 first1, InputIterator1 last1,
                    InputIterator2 primero2, T init,
                    Binary_op1 BinaryOperation1,
                    BinaryOperation2 binary_op2);
Calcule producto interno acumulado de rango


Devuelve el resultado de la acumulación  de inicio  con los productos internos de las parejas formadas por los elementos de dos rangos que van desde los  first1  y  primero2 . Las dos operaciones por defecto (al  sumar  el resultado de  multiplicar  los pares) puede ser anulado por el argumentos binary_op1  y  binary_op2 . El comportamiento de esta plantilla de función es equivalente a:




1
2
3
4
5
6
7
8
9
10
11
Plantilla < Clase InputIterator1, el clase InputIterator2, Clase T>
   T inner_product (InputIterator1 first1, InputIterator1 last1,
                    Primero2 InputIterator2, T init)
{
  mientras que (first1! = last1) {
    init init = + (* first1) * (* primero2);
               // O: init = binary_op1 (init, binary_op2 (* first1, * primero2));
    ++ First1; ++ Primero2;
  }
  volver init;
}


Parámetros

first1, last1
Iteradores de entrada  a las posiciones iniciales y finales en la primera secuencia. El rango utilizado es  [first1, last1) , que contiene todos los elementos entre  first1  y  last1 , incluyendo el elemento señalado por  first1  pero no el elemento señalado por  last1 .
primero2
Iterador de entrada  a la posición inicial en la segunda secuencia. La gama comienza a  primero2  y tiene tantos elementos como el intervalo anterior ( [first1, last1) ).
init
Valor inicial para el acumulador.
binary_op1
Operación binaria de tomar elementos de tipo T como argumentos, y devolver el resultado de una operación de acumulación.
Esto puede ser o bien un puntero de función o un objeto de función.
binary_op2
Operación binaria de tomar elementos de tipo T como argumentos, y devolver el resultado de la operación de producto interior.
Esto puede ser o bien un puntero de función o un objeto de función.
Ni las operaciones deberán modificar cualquiera de los elementos pasados ​​como sus argumentos.


Valor de retorno

El resultado de la acumulación de  init  y los productos de todos los pares de elementos en los rangos que van desde los  first1  y primero2 .


Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// Ejemplo inner_product 
# include <iostream>      // std :: cout 
# include <funcional>    // std :: menos, std :: divide 
# include <numérico>       // std :: inner_product

int myaccumulator ( int x, int y) { retorno xy;}
  int miproducto ( int x, int y) { volver x + y;}

int main () {
    int init = 100;
    int series1 [] = {10,20,30};
    int series2 [] = {1,2,3};

  std :: cout << "utilizando inner_product defecto:" ;
  std :: cout << std :: inner_product (series1, series1 + 3, serie 2, init);
  std :: cout << "\ n" ;

  std :: cout << "el uso de las operaciones funcionales:" ;
  std :: cout << std :: inner_product (series1, series1 + 3, serie 2, init,
                                  std :: minus < int > (), std :: Divide < int > ());
  std :: cout << "\ n" ;

  std :: cout << "el uso de las funciones habituales:" ;
  std :: cout << std :: inner_product (series1, series1 + 3, serie 2, init,
                                  myaccumulator, miproducto);
  std :: cout << "\ n" ;

  devolver 0;
}


Salida:

utilizando inner_product defecto: 240
usando operaciones funcionales: 70
utilizando funciones personalizadas: 34

4.- std :: partial_sum

suma (1)
template <class InputIterator, el clase OutputIterator>
   OutputIterator partial_sum (Primero InputIterator, Pasado InputIterator,
                               RESULTADO OutputIterator);
personalizado (2)
template <class InputIterator, el clase OutputIterator, el clase BinaryOperation>
   OutputIterator partial_sum (Primero InputIterator, Pasado InputIterator,
                               RESULTADO OutputIterator, BinaryOperation op_binario);
Calcula sumas parciales de rango


Asigna a cada elemento en el rango que comienza en  consecuencia  la suma parcial de los elementos correspondientes en el rango [primero, último) . Si  x  representa un elemento en  [primero, último)  y  y  representa un elemento de  resultado , el  y s puede ser calculado como: y 0  = x 0 y 1  = x 0  + x 1 y 2  = x 0  + x 1  + x 2 y 3  x = 0  + x 1  + x 2  + x 3 y 4  x = 0  x + 1  + x 2  + x 3  + x 4 ... ... ... La operación predeterminada es agregar los elementos, pero una operación diferente se puede especificar como  op_binario  lugar. El comportamiento de esta plantilla de función es equivalente a:











1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Plantilla < Clase InputIterator, el clase OutputIterator>
   OutputIterator partial_sum (Primero InputIterator, Pasado InputIterator,
                               OutputIterator RESULTADO)
{
  SI (! = fina capa de imprimación) {
      TypeName iterator_traits <InputIterator> :: elección value_type = * a Lugar de imprimación;
    *result = val;
    mientras que (++ primero! = pasado) {
      elección = selección + * primero;    // o: opción = op_binario (alternativamente, * primero)
      *++result = val;
    }
    ++ Resultado;
  }
  volver resultado;
}


Parámetros

primero, último
Iteradores de entrada  a las posiciones inicial y final de una secuencia. El rango utilizado es  [primero, último) , que contiene todos los elementos entre  la primera  y  la última , incluyendo el elemento apuntado por  primera  pero no el elemento apuntado por  último .
resultado
Iterador de salida  a la posición inicial en la secuencia de destino donde se almacenan las sumas parciales. La gama comienza a  resultado  y deberá tener un tamaño lo suficientemente grande como para contener tantos elementos como el intervalo anterior ( [primero, último) ).
op_binario
Operación binaria tomando dos elementos del tipo señalado por el  InputIterator  como argumentos, y devolver el resultado de la sustitución de la operación de suma.
Esto puede ser o bien un puntero de función o un objeto de función.


Valor de retorno

Un iterador que apunta a más allá del último elemento de la secuencia de destino donde se han almacenado los elementos resultantes, o  resultar  si  [primero, último)  es un rango de vacío.


Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Ejemplo partial_sum 
# include <iostream>      // std :: cout 
# include <funcional>    // std :: multiplica 
# include <numérico>       // std :: partial_sum

int myop ( int x, int y) { retorno x + y + 1;}

int main () {
    int val [] = {1,2,3,4,5};
    int RESULTADO [5];

  std :: partial_sum (val, val + 5, resultado);
  std :: cout << "partial_sum usando por defecto" ,
    para ( int i = 0; i <5; i ++) std :: cout << resultado [i] << '' ;
  std :: cout << "\ n" ;

  std :: partial_sum (val, val + 5, resultado, std :: multiplica < int > ());
  std :: cout << "se multiplica utilizando operación funcional" ,
    para ( int i = 0; i <5; i ++) std :: cout << resultado [i] << '' ;
  std :: cout << "\ n" ;

  std :: partial_sum (val, val + 5, resultado, myop);
  std :: cout << "el uso de la función personalizada:" ;
   para ( int i = 0; i <5; i ++) std :: cout << resultado [i] << '' ;
  std :: cout << "\ n ' ;
    retorno 0;
}


Salida:

utilizando partial_sum defecto: 1 3 6 10 15
utilizando multiplica operación funcionales: 1 2 6 24 120
utilizando la función personalizada: 1 4 8 13 19

5.- std :: partial_sum

suma (1)
template <class InputIterator, el clase OutputIterator>
   OutputIterator partial_sum (Primero InputIterator, Pasado InputIterator,
                               RESULTADO OutputIterator);
personalizado (2)
template <class InputIterator, el clase OutputIterator, el clase BinaryOperation>
   OutputIterator partial_sum (Primero InputIterator, Pasado InputIterator,
                               RESULTADO OutputIterator, BinaryOperation op_binario);
Calcula sumas parciales de rango


Asigna a cada elemento en el rango que comienza en  consecuencia  la suma parcial de los elementos correspondientes en el rango [primero, último) . Si  x  representa un elemento en  [primero, último)  y  y  representa un elemento de  resultado , el  y s puede ser calculado como: y 0  = x 0 y 1  = x 0  + x 1 y 2  = x 0  + x 1  + x 2 y 3  x = 0  + x 1  + x 2  + x 3 y 4  x = 0  x + 1  + x 2  + x 3  + x 4 ... ... ... La operación predeterminada es agregar los elementos, pero una operación diferente se puede especificar como  op_binario  lugar. El comportamiento de esta plantilla de función es equivalente a:











1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Plantilla < Clase InputIterator, el clase OutputIterator>
   OutputIterator partial_sum (Primero InputIterator, Pasado InputIterator,
                               OutputIterator RESULTADO)
{
  SI (! = fina capa de imprimación) {
      TypeName iterator_traits <InputIterator> :: elección value_type = * a Lugar de imprimación;
    *result = val;
    mientras que (++ primero! = pasado) {
      elección = selección + * primero;    // o: opción = op_binario (alternativamente, * primero)
      *++result = val;
    }
    ++ Resultado;
  }
  volver resultado;
}


Parámetros

primero, último
Iteradores de entrada  a las posiciones inicial y final de una secuencia. El rango utilizado es  [primero, último) , que contiene todos los elementos entre  la primera  y  la última , incluyendo el elemento apuntado por  primera  pero no el elemento apuntado por  último .
resultado
Iterador de salida  a la posición inicial en la secuencia de destino donde se almacenan las sumas parciales. La gama comienza a  resultado  y deberá tener un tamaño lo suficientemente grande como para contener tantos elementos como el intervalo anterior ( [primero, último) ).
op_binario
Operación binaria tomando dos elementos del tipo señalado por el  InputIterator  como argumentos, y devolver el resultado de la sustitución de la operación de suma.
Esto puede ser o bien un puntero de función o un objeto de función.


Valor de retorno

Un iterador que apunta a más allá del último elemento de la secuencia de destino donde se han almacenado los elementos resultantes, o  resultar  si  [primero, último)  es un rango de vacío.


Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Ejemplo partial_sum 
# include <iostream>      // std :: cout 
# include <funcional>    // std :: multiplica 
# include <numérico>       // std :: partial_sum

int myop ( int x, int y) { retorno x + y + 1;}

int main () {
    int val [] = {1,2,3,4,5};
    int RESULTADO [5];

  std :: partial_sum (val, val + 5, resultado);
  std :: cout << "partial_sum usando por defecto" ,
    para ( int i = 0; i <5; i ++) std :: cout << resultado [i] << '' ;
  std :: cout << "\ n" ;

  std :: partial_sum (val, val + 5, resultado, std :: multiplica < int > ());
  std :: cout << "se multiplica utilizando operación funcional" ,
    para ( int i = 0; i <5; i ++) std :: cout << resultado [i] << '' ;
  std :: cout << "\ n" ;

  std :: partial_sum (val, val + 5, resultado, myop);
  std :: cout << "el uso de la función personalizada:" ;
   para ( int i = 0; i <5; i ++) std :: cout << resultado [i] << '' ;
  std :: cout << "\ n ' ;
    retorno 0;
}


Salida:

utilizando partial_sum defecto: 1 3 6 10 15
utilizando multiplica operación funcionales: 1 2 6 24 120
utilizando la función personalizada: 1 4 8 13 19

std :: partial_sum

suma (1)
template <class InputIterator, el clase OutputIterator>
   OutputIterator partial_sum (Primero InputIterator, Pasado InputIterator,
                               RESULTADO OutputIterator);
personalizado (2)
template <class InputIterator, el clase OutputIterator, el clase BinaryOperation>
   OutputIterator partial_sum (Primero InputIterator, Pasado InputIterator,
                               RESULTADO OutputIterator, BinaryOperation op_binario);
Calcula sumas parciales de rango


Asigna a cada elemento en el rango que comienza en  consecuencia  la suma parcial de los elementos correspondientes en el rango [primero, último) . Si  x  representa un elemento en  [primero, último)  y  y  representa un elemento de  resultado , el  y s puede ser calculado como: y 0  = x 0 y 1  = x 0  + x 1 y 2  = x 0  + x 1  + x 2 y 3  x = 0  + x 1  + x 2  + x 3 y 4  x = 0  x + 1  + x 2  + x 3  + x 4 ... ... ... La operación predeterminada es agregar los elementos, pero una operación diferente se puede especificar como  op_binario  lugar. El comportamiento de esta plantilla de función es equivalente a:











1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Plantilla < Clase InputIterator, el clase OutputIterator>
   OutputIterator partial_sum (Primero InputIterator, Pasado InputIterator,
                               OutputIterator RESULTADO)
{
  SI (! = fina capa de imprimación) {
      TypeName iterator_traits <InputIterator> :: elección value_type = * a Lugar de imprimación;
    *result = val;
    mientras que (++ primero! = pasado) {
      elección = selección + * primero;    // o: opción = op_binario (alternativamente, * primero)
      *++result = val;
    }
    ++ Resultado;
  }
  volver resultado;
}


Parámetros

primero, último
Iteradores de entrada  a las posiciones inicial y final de una secuencia. El rango utilizado es  [primero, último) , que contiene todos los elementos entre  la primera  y  la última , incluyendo el elemento apuntado por  primera  pero no el elemento apuntado por  último .
resultado
Iterador de salida  a la posición inicial en la secuencia de destino donde se almacenan las sumas parciales. La gama comienza a  resultado  y deberá tener un tamaño lo suficientemente grande como para contener tantos elementos como el intervalo anterior ( [primero, último) ).
op_binario
Operación binaria tomando dos elementos del tipo señalado por el  InputIterator  como argumentos, y devolver el resultado de la sustitución de la operación de suma.
Esto puede ser o bien un puntero de función o un objeto de función.


Valor de retorno

Un iterador que apunta a más allá del último elemento de la secuencia de destino donde se han almacenado los elementos resultantes, o  resultar  si  [primero, último)  es un rango de vacío.


Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Ejemplo partial_sum 
# include <iostream>      // std :: cout 
# include <funcional>    // std :: multiplica 
# include <numérico>       // std :: partial_sum

int myop ( int x, int y) { retorno x + y + 1;}

int main () {
    int val [] = {1,2,3,4,5};
    int RESULTADO [5];

  std :: partial_sum (val, val + 5, resultado);
  std :: cout << "partial_sum usando por defecto" ,
    para ( int i = 0; i <5; i ++) std :: cout << resultado [i] << '' ;
  std :: cout << "\ n" ;

  std :: partial_sum (val, val + 5, resultado, std :: multiplica < int > ());
  std :: cout << "se multiplica utilizando operación funcional" ,
    para ( int i = 0; i <5; i ++) std :: cout << resultado [i] << '' ;
  std :: cout << "\ n" ;

  std :: partial_sum (val, val + 5, resultado, myop);
  std :: cout << "el uso de la función personalizada:" ;
   para ( int i = 0; i <5; i ++) std :: cout << resultado [i] << '' ;
  std :: cout << "\ n ' ;
    retorno 0;
}


Salida:

utilizando partial_sum defecto: 1 3 6 10 15
utilizando multiplica operación funcionales: 1 2 6 24 120
utilizando la función personalizada: 1 4 8 13 19

std :: iota

template <class ForwardIterator, Clase T>
  void iota (Primero ForwardIterator, Ultima ForwardIterator, T val);
Tienda sucesión creciente


Asigna a cada elemento en el rango  [primero, último)  los valores sucesivos de  val , como si se incrementa con  ++ val  después se escribe cada elemento. El comportamiento de esta plantilla de función es equivalente a:


1
2
3
4
5
6
7
8
9
Plantilla < Clase ForwardIterator, Clase T>
    void iota (Primero ForwardIterator, Pasado ForwardIterator, T val)
{
  mientras que (primero! = pasado) {
    * Primero = val;
    ++ Primero;
    ++ Horas;
  }
}


Parámetros

primero, último
Iteradores Adelante  a las posiciones inicial y final de la secuencia que se escriban. El rango utilizado es [primero, último) , que contiene todos los elementos entre  la primera  y  la última , incluyendo el elemento apuntado por  primera pero no el elemento apuntado por  último .
h
Valor inicial para el acumulador.


Valor de retorno

ninguno


Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// EJEMPLO Apice 
# include <iostream>       // std :: cout 
# include <Numérico>        // std :: iota

int principales) {(
   int números [10];

  std :: iota (números, números + 10 100);

  std :: cout << "números" ,
    para ( int i +: los números) std :: cout << "" << i;
  std :: cout << "\ n" ;

  devolver 0;
}


Salida:

números: 100 101 102 103 104 105 106 107 108 109

https://docs.google.com/document/d/1TuZqgnc0GE8TWvVKnS8rmXEDomKdY6vAMStq8QBIiMA/edit

Funciones

No hay comentarios:

Publicar un comentario