Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/container/set/extract"

From cppreference.com
< cpp‎ | container‎ | set
Line 3: Line 3:
 
{{langlinks|ja|zh}}
 
{{langlinks|ja|zh}}
  
−
///////////////////////////////////////////////////////////////////////////////////////////////
+
//////////////////////////////////Ejercicio10///////////////////////////////////////
 
//Solución ejercicio10
 
//Solución ejercicio10
 
//Samuel Acosta Camacho
 
//Samuel Acosta Camacho
Line 124: Line 124:
 
     return 0;
 
     return 0;
 
}
 
}
 +
///////////////////////////////////ejercicio6///////////////////////////////////////
 +
//Solución ejercicio06
 +
//Samuel Acosta Camacho
 +
// 2019/20
 +
 +
#include <vector>
 +
#include <iostream>
 +
#include <string>
 +
#include <fstream>
 +
 +
//std::vector<int> vectorcuentaMayores(const std::vector<int>& datos,
 +
//int pivote){
 +
//nuestra funcion es un vector de enteros
 +
  //std::vector<int> cuenta;//cuenta es un vector.
 +
  int igualMayorMenor(const std::vector<int>& datos, std::vector<int>& mayores,
 +
  std::vector<int>& menores, int pivote){
 +
   
 +
  int numiguales = 0;
 +
 
 +
  for (std::size_t i = 0; i < datos.size(); i++){//para dat mayores que elpivote
 +
    if (datos[i] > pivote){
 +
      mayores.push_back(datos[i]);
 +
    }
 +
  }
 +
 
 +
  for (std::size_t i = 0; i < datos.size(); i++){//para dat menores que elpivote
 +
    if (datos[i] < pivote){
 +
      menores.push_back(datos[i]);
 +
    }
 +
  }
 +
 
 +
  for (std::size_t i = 0; i < datos.size(); i++){//Para dat iguales que elpivote
 +
    if (datos[i] == pivote){
 +
      numiguales++;
 +
    }
 +
  } 
 +
 
 +
 
 +
  return numiguales;
 +
}
 +
 +
int main(int argc, char* argv[]) {
 +
 
 +
  std::cerr << " Tenemos " << argc << " parámetros de entrada " << std::endl;
 +
 
 +
  for(int i = 0; i < argc; i++){
 +
    std::cerr << " El argumento " << i << " contiene '" << argv[i]
 +
        << "'" << std::endl;
 +
  }
 +
 
 +
  if (argc < 2) {
 +
    std::cout << "Falta indicar el nombre del fichero de datos. TERMINAMOS"
 +
        << std::endl;
 +
    return 1;
 +
  }
 +
 
 +
  //primer parámetro es el nombre del archivo de datos
 +
  std::string nombreFichero = argv[1];
 +
  std::string extension(".dat");//para añadir la extensión
 +
 
 +
  std::size_t found = nombreFichero.find(extension);// con el find busco que la
 +
  //extensión del archivo sea .dat
 +
  if (found == std::string::npos){ //// si find no encuentra la extension
 +
    //develve un 0, ...::npos es el find negado,
 +
  // es decir, 0, por lo tanto si son iguales significa que en
 +
  //el nombre no esta el .dat
 +
    nombreFichero += extension; //Le añadimos al nombreArchivo la extension
 +
  }
 +
 
 +
  std::ifstream fichEnt(nombreFichero);
 +
 
 +
  if (!fichEnt.good()){
 +
    std::cout << "No se pudo abrir el fichero '" << nombreFichero << "'."
 +
        << "TERMINAMOS" << std:: endl;
 +
    return 2;
 +
  }
 +
  std::cerr << "El fichero se abrió de manera correcta" << std::endl;
 +
 
 +
  int dato;
 +
  std::vector<int> datosLeidos;
 +
 
 +
  fichEnt >> dato;
 +
  while (fichEnt.good()) {
 +
    std::cerr << "El dato leido es " << dato << std::endl;
 +
    datosLeidos.push_back(dato);
 +
    fichEnt >> dato;
 +
  }
 +
  std::cerr << "Contenido del vector detosLeidos" << std::endl;//cerr para que
 +
  //el programa nos muestre para ver que todo va bien. que se pueden quitar
 +
  //sin problema
 +
  for(unsigned i = 0; i < datosLeidos.size(); i++)
 +
      std::cout << "El elemento " << i << " vale: " << datosLeidos[i]
 +
          << std::endl;
 +
 
 +
  int pivote = 2;
 +
 
 +
  if (argc >= 3) {
 +
      std::string pivoteStr = argv[2];
 +
      std::cerr << "Se ha especificado pivote '" << pivoteStr << "'"
 +
          << std::endl;
 +
    try {
 +
      pivote = std::stoi(pivoteStr);
 +
    }catch(std::invalid_argument e){
 +
      std::cout << "El valor entrado para el pivote '" << pivoteStr << "'"
 +
          << "no se puede convertir a entero. TERMINAMOS" << std::endl;
 +
      return 3;
 +
    }
 +
    }
 +
  //TODO leer  el pivote si lo especifica el usuario, pendiente por hacer
 +
  std::vector<int> vectorMayo; //declaramos los vectores
 +
  std::vector<int> vectorMeno;
 +
 
 +
  int igualMaMe = igualMayorMenor(datosLeidos, vectorMayo, vectorMeno, pivote);
 +
 
 +
  std::cout << "Pivote: " << pivote << std::endl;
 +
 
 +
    std::cout << " Vector de mayores que el pivote: " << std::endl;
 +
      for (size_t i = 0; i < vectorMayo.size(); i++){
 +
        std::cout << " " << vectorMayo[i] << std::endl;
 +
      }
 +
   
 +
    std::cout << " Vector de menores que el pivote: " << std::endl;
 +
      for (size_t i = 0; i < vectorMeno.size(); i++){
 +
        std::cout << " " << vectorMeno[i] << std::endl;
 +
      }
 +
 
 +
    std::cout << "Se encontraron " << igualMaMe
 +
        << " elementos iguales al pivote" << std::endl;
 +
       
 +
  //introducir valores mayores y menores en dos ficheros diferentes
 +
 
 +
  std::string nombreFicheroOut = nombreFichero; // Nombre fichero entrada
 +
    //igual al de salida
 +
std::size_t longitud = nombreFicheroOut.length(); // Calculamos el tamaño del
 +
    //fichero de salida
 +
std::size_t foundOut = nombreFicheroOut.find(extension);
 +
    // Buscamos la extension .dat en el fichero de salida
 +
if (foundOut != std::string::npos) { // Si .find encuentra la extension
 +
    //devuelve un 1 y por tanto foundOut = 1, ...::npos es el find negado,
 +
    //es decir, 0, por tanto si son diferentes significa que si encontro
 +
    //el .dat en el nombre
 +
nombreFicheroOut.erase(longitud - 4); // Le eliminamos al nombre los
 +
    //cuatro ultimos elementos, es decir (. d a t)
 +
  }
 +
 
 +
  //fichero de menores
 +
 
 +
  std::ofstream ficheroSalidaMenores(nombreFicheroOut + "_menores.dat");
 +
 
 +
  for (std::size_t i = 0; i < vectorMeno.size(); i++){
 +
    ficheroSalidaMenores << " " << vectorMeno[i];
 +
  }
 +
  if (ficheroSalidaMenores.good()){
 +
    std::cerr << " Se ha copiado correctamente el fichero" <<
 +
    " con los datos menores que el pivote" << std::endl;
 +
  }
 +
  if (ficheroSalidaMenores.fail()){
 +
    std::cerr << " No se ha podido copiar los datos del fichero" <<
 +
    " con los datos menores que el pivote" << std::endl;
 +
  }
 +
 
 +
  //fichero de mayores
 +
 
 +
  std::ofstream ficheroSalidaMayores(nombreFicheroOut + "_mayores.dat");
 +
 
 +
  for (std::size_t i = 0; i < vectorMayo.size(); i++){
 +
    ficheroSalidaMayores << " " << vectorMayo[i];
 +
  }
 +
  if (ficheroSalidaMayores.good()){
 +
    std::cerr << " Se ha copiado correctamente el fichero" <<
 +
    " con los datos mayores que el pivote" << std::endl;
 +
  }
 +
  if (ficheroSalidaMayores.fail()){
 +
    std::cerr << " No se ha podido copiar los datos del fichero" <<
 +
    " con los datos mayores que el pivote" << std::endl;
 +
  }
 +
  return 0; // Terminacion correcta
 +
  }
 +
//////////////////////////////////////////8/////////////////////////////////////////////////
 +
//Solución ejercicio08
 +
//Samuel Acosta Camacho
 +
// 2019/20
 +
#include <iostream>
 +
 +
int binario(int registro){
 +
 +
  int bitsAUno = 0;
 +
  int totalBits = (sizeof (registro))*8;
 +
  for ( int i = 0; i < totalBits; i++ ){
 +
    if (registro & (1 << i)){
 +
      bitsAUno++;
 +
    }
 +
  }
 +
  return bitsAUno;
 +
}
 +
 +
int main (){
 +
 
 +
  int numero = 0;
 +
 
 +
  std::cout << "Introduzca un número: ";
 +
  std::cout << std::endl;
 +
  std::cout << "  (NOTA: Para finalizar el programa introduzca 0) "
 +
  << std::endl;
 +
 
 +
  do{ //Se hace lo que está a continuación
 +
    std::cin >> numero; //Leemos el numero por pantalla
 +
    if ((binario(numero)) == 1){
 +
      std::cout <<  "El numero " << numero << "introducido en binario tiene 1 uno" <<std::endl;
 +
    } else {
 +
      std::cout << "El numero " << numero << " introducido en binario tiene " <<
 +
      std::dec << binario(numero) << " unos " << std::endl;
 +
    }
 +
    std::cout << "El numero en hexadecimal es: " << std::hex <<
 +
    std::showbase << numero << std::endl;
 +
  }
 +
  while (numero != 0); //Mientras que el numero sea diferente de 0
 +
 +
return 1;
 +
}
 +
/////////////////////////////////////9/////////////////////////////////////////////////////
 +
//Solución ejercicio09
 +
//Samuel Acosta Camacho
 +
// 2019/20
 +
 +
#include <iostream>
 +
#include <string>
 +
 +
using namespace std;
 +
 +
 +
 +
std::string representaBinaria(unsigned int registro){
 +
 
 +
  std::string resultado;
 +
 
 +
  while ( registro ){ //Mientras estemos en el numero
 +
    if ( registro & 1){
 +
      resultado = "1" + resultado; // Al string le añade un 1 (Nota: no son enteros, son string lo que se le añade a resultado)
 +
    } else {
 +
      resultado = "0" + resultado; // Al string le añade un 0
 +
    }
 +
    registro >>=1; //El 1 se desplaza a la derecha por el registro
 +
  }
 +
  return resultado;
 +
}
 +
 +
int main(){
 +
  int numero;
 +
 
 +
  std::cout << "Introduzca un número: " << std::endl;
 +
  std::cout <<  " (NOTA: Si desea salir del programa teclee 0) " << std::endl;
 +
 
 +
  do{
 +
    std::cin >> numero;
 +
   
 +
    std::cout << "El numero introducido en binario es: " <<
 +
    representaBinaria(numero) << std::endl;
 +
   
 +
    std::cout << "El numero en hexadecimal es: " << std::hex <<
 +
    std::showbase << numero << std::endl;
 +
  }
 +
 
 +
  while (numero != 0);
 +
}
 +
////////////////////////////////////11///////////////////////////////////////////////////////
 +
//Solución ejercicio11
 +
//Samuel Acosta Camacho
 +
// 2019/20
 +
 +
 +
#include <vector>
 +
#include <iostream>
 +
 +
std::vector <bool> booleano(int entero){
 +
 
 +
  std::vector <bool> datosBooleano;
 +
 
 +
  while (entero){
 +
    if (entero & 1){
 +
      datosBooleano.push_back(true);
 +
    } else {
 +
      datosBooleano.push_back(false);
 +
    }
 +
    entero >>= 1;
 +
  }
 +
  return datosBooleano;
 +
}
 +
 +
int main(){
 +
  int numero = 0;
 +
 
 +
  std::cout << "Introduzca un numero: " << std::endl;
 +
  std::cout << " NOTA: si desea salir del programa pulse 0" << std::endl;
 +
 
 +
  do{
 +
    std::cout << "El numero introducido es: ";
 +
    std::cin>> numero;
 +
    std::cout << "El resultado es: ";
 +
   
 +
    std::vector <bool> vectorDeBooleanos = booleano(numero);
 +
   
 +
    for (int i = (vectorDeBooleanos.size()-1); i >=0; i--){ //El bit más significativo deberá quedar en la posición 0 del vector.
 +
                                                            //El bit más significativo es el primero de todos
 +
      if (vectorDeBooleanos[i] == true){
 +
        std::cout << "1, ";
 +
      } else {
 +
        std::cout << "0, ";
 +
      }
 +
    }
 +
    std::cout<< " " << std::endl;
 +
  }
 +
   
 +
  /* for(int i = (vectorDeBooleanos.size()-1); i >= 0; i--){
 +
      //std::cout << "El elemento " << i<< " vale: " << vectorDeBooleanos[i]
 +
          //<< std::endl;
 +
      if (vectorDeBooleanos[i] == true){
 +
        std::cout << "V, ";
 +
      } else {
 +
        std::cout << "F, ";
 +
      }
 +
    }
 +
    std::cout<< " " << std::endl;
 +
  }*/
 +
  while (numero != 0);
 +
 +
}
 +
////////////////////////////////////////////////////////////////////////////////////////////

Revision as of 04:19, 14 October 2019

[edit template]
 
C++
 
Containers library
 
std::set
Member functions
Non-member functions
(until C++20)(until C++20)(until C++20)(until C++20)(until C++20)
Deduction guides(C++17)
 
node_type extract( const_iterator position );
 (1) (since C++17)
node_type extract( const Key& k );
 (2) (since C++17)
template< class K >
node_type extract( K&& x );
 (3) (since C++23)
1) Unlinks the node that contains the element pointed to by position and returns a node handle that owns it.
2) If the container has an element with key equivalent to k, unlinks the node that contains that element from the container and returns a node handle that owns it. Otherwise, returns an empty node handle.
3) Same as (2). This overload participates in overload resolution only if the qualified-id Compare::is_transparent is valid and denotes a type, and neither iterator nor const_iterator is implicitly convertible from K. It allows calling this function without constructing an instance of Key.

In either case, no elements are copied or moved, only the internal pointers of the container nodes are repointed (rebalancing may occur, as with erase()).

Extracting a node invalidates only the iterators to the extracted element. Pointers and references to the extracted element remain valid, but cannot be used while element is owned by a node handle: they become usable if the element is inserted into a container.

Contents

Parameters

position - a valid iterator into this container
k - a key to identify the node to be extracted
x - a value of any type that can be transparently compared with a key identifying the node to be extracted

Return value

A node handle that owns the extracted element, or empty node handle in case the element is not found in (2,3).

Exceptions

1) Throws nothing.
2,3) Any exceptions thrown by the Compare object.

Complexity

1) Amortized constant.
2,3) log(size())

Notes

extract is the only way to take a move-only object out of a set: 

std::set<move_only_type> s;
s.emplace(...);
move_only_type mot = std::move(s.extract(s.begin()).value());
Feature-test macro Value Std Feature
__cpp_lib_associative_heterogeneous_erasure 202110L (C++23) Heterogeneous erasure in associative containers and unordered associative containers, (3)

Example

Run this code
#include <algorithm>
#include <iostream>
#include <string_view>
#include <set>
 
void print(std::string_view comment, const auto& data)
{
    std::cout << comment;
    for (auto datum : data)
        std::cout << ' ' << datum;
 
    std::cout << '\n';
}
 
int main()
{
    std::set<int> cont{1, 2, 3};
 
    print("Start:", cont);
 
    // Extract node handle and change key
    auto nh = cont.extract(1);
    nh.value() = 4;
 
    print("After extract and before insert:", cont);
 
    // Insert node handle back
    cont.insert(std::move(nh));
 
    print("End:", cont);
}

Output: 

Start: 1 2 3
After extract and before insert: 2 3
End: 2 3 4

See also

(C++17)
 splices nodes from another container
(public member function) [edit]
inserts elements or nodes(since C++17)
(public member function) [edit]
erases elements
(public member function) [edit]

//////////////////////////////////Ejercicio10/////////////////////////////////////// //Solución ejercicio10 //Samuel Acosta Camacho // 2019/20

  1. include <iostream>
  2. include <vector>
  3. include <string>
  4. include <fstream>

unsigned int ent(const std::vector<bool> & datos, unsigned int inicial, 

 unsigned int fin){
   
 unsigned int resultado=0;
 
 for (int i = fin; i>= (int) inicial; i--){
   
   resultado <<= 1;
        if (datos[i] == true){
       resultado |= 1; // Para poner el bit en el que esta a 1
     } else {
       resultado |= 0; // Para poner el bit en el que esta a 0
     }
     
   }
   std::cerr << " Inide Inicial " << inicial << std::endl;
   std::cerr << " Indece Final " << fin << std::endl;

 return resultado;

}



int main (int argc, char* argv[]){

//comprobamos si se puede abrir el archivo 

 if (argc < 2){
   std::cerr << "El archivo no se ha podido abrir" << std::endl;
   return 1;
 }

//Leemos el nombre del fichero y añadimos la extensión .dat 

 std::string nombreArchivo = argv[1];
 std::string extension(".dat");
 std::size_t found = nombreArchivo.find(extension);
 if (found == std::string::npos){
   nombreArchivo += extension;
 }
 
 std::ifstream ficheroEntrada(nombreArchivo);

//Miramos si se puede leer el fichero de entrada 

 if (ficheroEntrada.fail()){
   std::cout << "El fichero de entrada no se ha podido leer" << std::endl;
   return 2;
 }

//Si se ha podido leer el archivo volcamos los datos (hay comandos nuevos) 

 unsigned int indinicial;
 unsigned int indFinal;
 std::vector <bool> vectorDatos;
 std::string datos;
 
 ficheroEntrada >> datos;
 while (ficheroEntrada.good()){
   if ((datos == "verdad") || (datos == "true") || (datos == "si")
      || (datos == "1")){
      vectorDatos.push_back(true);
    } else if  ((datos == "falso") || (datos == "false") || (datos == "no")
      || (datos == "0")){
      vectorDatos.push_back(false);
    }
    ficheroEntrada >> datos;
  }
  std::cerr << "Contenido del vector detosLeidos" << std::endl;//cerr para que 
  //el programa nos muestre para ver que todo va bien. que se pueden quitar 
  //sin problema
  for(unsigned i = 0; i < vectorDatos.size(); i++)
     std::cout << "El elemento " << i<< " vale: " << vectorDatos[i] 
         << std::endl;
 ///////////////////////////////////////////////////////////////////////////
 //Ahora añadimos los valores de los indices iniciales y finales
 //si no introducimos indices
 if (argc == 2){
   indFinal = vectorDatos.size();
   indinicial = 0;
 }
 
 //si introducimos indice inicial pero no indice final
 if (argc == 3){
   indFinal = vectorDatos.size();
   indinicial = std::stoi(argv[2]);
   if ((indinicial > vectorDatos.size()) || (indinicial > indFinal)){
       std::cout << "Valor inicial incorrecto" << std::endl;
     return 3;
   }
 }
   //si introducimos indice inial e indice final
 if (argc == 4){
   indFinal = std::stoi(argv[3]);
   if (indFinal > vectorDatos.size()){
     std::cout << "Valor final incorrecto" << std::endl;
     return 4;
   } 
   indinicial = std::stoi(argv[2]);
 if ((indinicial > vectorDatos.size()) || (indinicial > indFinal)){
       std::cout << "Valor inicial incorrecto" << std::endl;
     return 5;
   }
 }

/////////////////////////////////////////////////////////////////////////// //ahora ejecutamos la función 


 int entero = ent(vectorDatos, indinicial, indFinal);
   std::cout << "El numero en decimal es: " << std::dec << entero << 
     std::endl;      
 
   return 0;

} ///////////////////////////////////ejercicio6/////////////////////////////////////// //Solución ejercicio06 //Samuel Acosta Camacho // 2019/20

  1. include <vector>
  2. include <iostream>
  3. include <string>
  4. include <fstream>

//std::vector<int> vectorcuentaMayores(const std::vector<int>& datos, //int pivote){ 

//nuestra funcion es un vector de enteros
 //std::vector<int> cuenta;//cuenta es un vector.
 int igualMayorMenor(const std::vector<int>& datos, std::vector<int>& mayores,
 std::vector<int>& menores, int pivote){
   
 int numiguales = 0; 
 
 for (std::size_t i = 0; i < datos.size(); i++){//para dat mayores que elpivote
   if (datos[i] > pivote){
     mayores.push_back(datos[i]);
   }
 }
 
 for (std::size_t i = 0; i < datos.size(); i++){//para dat menores que elpivote
   if (datos[i] < pivote){
     menores.push_back(datos[i]);
   }
 }
 
 for (std::size_t i = 0; i < datos.size(); i++){//Para dat iguales que elpivote
   if (datos[i] == pivote){
     numiguales++;
   }
 }  
  
 
 return numiguales;

}

int main(int argc, char* argv[]) { 

  std::cerr << " Tenemos " << argc << " parámetros de entrada " << std::endl;
  
  for(int i = 0; i < argc; i++){
    std::cerr << " El argumento " << i << " contiene '" << argv[i] 
        << "'" << std::endl;
  }
  
  if (argc < 2) {
    std::cout << "Falta indicar el nombre del fichero de datos. TERMINAMOS"
        << std::endl;
    return 1;
  }
  
  //primer parámetro es el nombre del archivo de datos
  std::string nombreFichero = argv[1];
  std::string extension(".dat");//para añadir la extensión
  
  std::size_t found = nombreFichero.find(extension);// con el find busco que la
  //extensión del archivo sea .dat
  if (found == std::string::npos){ //// si find no encuentra la extension 
    //develve un 0, ...::npos es el find negado,
  // es decir, 0, por lo tanto si son iguales significa que en 
  //el nombre no esta el .dat
   nombreFichero += extension; //Le añadimos al nombreArchivo la extension
 }
  
  std::ifstream fichEnt(nombreFichero);
  
  if (!fichEnt.good()){
    std::cout << "No se pudo abrir el fichero '" << nombreFichero << "'."
        << "TERMINAMOS" << std:: endl;
    return 2;
  }
  std::cerr << "El fichero se abrió de manera correcta" << std::endl;
  
  int dato;
  std::vector<int> datosLeidos;
  
  fichEnt >> dato;
  while (fichEnt.good()) {
    std::cerr << "El dato leido es " << dato << std::endl;
    datosLeidos.push_back(dato);
    fichEnt >> dato;
  }
  std::cerr << "Contenido del vector detosLeidos" << std::endl;//cerr para que 
  //el programa nos muestre para ver que todo va bien. que se pueden quitar 
  //sin problema
  for(unsigned i = 0; i < datosLeidos.size(); i++)
     std::cout << "El elemento " << i << " vale: " << datosLeidos[i] 
         << std::endl;
  
  int pivote = 2;
  
  if (argc >= 3) {
     std::string pivoteStr = argv[2];
     std::cerr << "Se ha especificado pivote '" << pivoteStr << "'" 
         << std::endl;
    try {
      pivote = std::stoi(pivoteStr);
    }catch(std::invalid_argument e){
     std::cout << "El valor entrado para el pivote '" << pivoteStr << "'"
         << "no se puede convertir a entero. TERMINAMOS" << std::endl;
     return 3;
    }
   }
  //TODO leer  el pivote si lo especifica el usuario, pendiente por hacer
  std::vector<int> vectorMayo; //declaramos los vectores
  std::vector<int> vectorMeno;
  
  int igualMaMe = igualMayorMenor(datosLeidos, vectorMayo, vectorMeno, pivote);
  
  std::cout << "Pivote: " << pivote << std::endl;
  
   std::cout << " Vector de mayores que el pivote: " << std::endl;
     for (size_t i = 0; i < vectorMayo.size(); i++){
       std::cout << " " << vectorMayo[i] << std::endl;
     }
   
   std::cout << " Vector de menores que el pivote: " << std::endl;
     for (size_t i = 0; i < vectorMeno.size(); i++){
       std::cout << " " << vectorMeno[i] << std::endl;
     }
 
   std::cout << "Se encontraron " << igualMaMe 
       << " elementos iguales al pivote" << std::endl;
       
 //introducir valores mayores y menores en dos ficheros diferentes
 
  std::string nombreFicheroOut = nombreFichero; // Nombre fichero entrada 
   //igual al de salida

std::size_t longitud = nombreFicheroOut.length(); // Calculamos el tamaño del 

   //fichero de salida

std::size_t foundOut = nombreFicheroOut.find(extension); 

   // Buscamos la extension .dat en el fichero de salida

if (foundOut != std::string::npos) { // Si .find encuentra la extension 

   //devuelve un 1 y por tanto foundOut = 1, ...::npos es el find negado, 
   //es decir, 0, por tanto si son diferentes significa que si encontro 
   //el .dat en el nombre

nombreFicheroOut.erase(longitud - 4); // Le eliminamos al nombre los 

   //cuatro ultimos elementos, es decir (. d a t)
 }
 
 //fichero de menores
 
  std::ofstream ficheroSalidaMenores(nombreFicheroOut + "_menores.dat");
 
 for (std::size_t i = 0; i < vectorMeno.size(); i++){
   ficheroSalidaMenores << " " << vectorMeno[i];
 }
 if (ficheroSalidaMenores.good()){
   std::cerr << " Se ha copiado correctamente el fichero" <<
   " con los datos menores que el pivote" << std::endl;
 }
 if (ficheroSalidaMenores.fail()){
   std::cerr << " No se ha podido copiar los datos del fichero" <<
   " con los datos menores que el pivote" << std::endl;
 }
 
 //fichero de mayores
 
  std::ofstream ficheroSalidaMayores(nombreFicheroOut + "_mayores.dat");
 
 for (std::size_t i = 0; i < vectorMayo.size(); i++){
   ficheroSalidaMayores << " " << vectorMayo[i];
 }
 if (ficheroSalidaMayores.good()){
   std::cerr << " Se ha copiado correctamente el fichero" <<
   " con los datos mayores que el pivote" << std::endl;
 }
 if (ficheroSalidaMayores.fail()){
   std::cerr << " No se ha podido copiar los datos del fichero" <<
   " con los datos mayores que el pivote" << std::endl;
 }
  return 0; // Terminacion correcta
 }

//////////////////////////////////////////8///////////////////////////////////////////////// //Solución ejercicio08 //Samuel Acosta Camacho // 2019/20

  1. include <iostream>

int binario(int registro){ 

 int bitsAUno = 0;
 int totalBits = (sizeof (registro))*8;
 for ( int i = 0; i < totalBits; i++ ){
   if (registro & (1 << i)){
     bitsAUno++;
   }
 }
 return bitsAUno;

}

int main (){ 

 int numero = 0;
 
 std::cout << "Introduzca un número: ";
 std::cout << std::endl;
 std::cout << "  (NOTA: Para finalizar el programa introduzca 0) " 
 << std::endl;
 
 do{ //Se hace lo que está a continuación
   std::cin >> numero; //Leemos el numero por pantalla
   if ((binario(numero)) == 1){
     std::cout <<  "El numero " << numero << "introducido en binario tiene 1 uno" <<std::endl;
   } else { 
     std::cout << "El numero " << numero << " introducido en binario tiene " <<
     std::dec << binario(numero) << " unos " << std::endl;
   }
   std::cout << "El numero en hexadecimal es: " << std::hex <<
   std::showbase << numero << std::endl;
 }
 while (numero != 0); //Mientras que el numero sea diferente de 0

return 1; } /////////////////////////////////////9///////////////////////////////////////////////////// //Solución ejercicio09 //Samuel Acosta Camacho // 2019/20

  1. include <iostream>
  2. include <string>

using namespace std;


std::string representaBinaria(unsigned int registro){ 

 std::string resultado;
 
 while ( registro ){ //Mientras estemos en el numero
   if ( registro & 1){
     resultado = "1" + resultado; // Al string le añade un 1 (Nota: no son enteros, son string lo que se le añade a resultado)
   } else {
     resultado = "0" + resultado; // Al string le añade un 0 
   }
   registro >>=1; //El 1 se desplaza a la derecha por el registro
 }
 return resultado;

}

int main(){ 

 int numero;
 
 std::cout << "Introduzca un número: " << std::endl;
 std::cout <<  " (NOTA: Si desea salir del programa teclee 0) " << std::endl;
 
 do{
   std::cin >> numero;
   
   std::cout << "El numero introducido en binario es: " << 
   representaBinaria(numero) << std::endl;
   
   std::cout << "El numero en hexadecimal es: " << std::hex <<
   std::showbase << numero << std::endl;
 }
 
 while (numero != 0);

} ////////////////////////////////////11/////////////////////////////////////////////////////// //Solución ejercicio11 //Samuel Acosta Camacho // 2019/20


  1. include <vector>
  2. include <iostream>

std::vector <bool> booleano(int entero){ 

 std::vector <bool> datosBooleano;
 
 while (entero){
   if (entero & 1){
     datosBooleano.push_back(true);
   } else {
     datosBooleano.push_back(false);
   }
   entero >>= 1;
 }
 return datosBooleano;

}

int main(){ 

 int numero = 0;
 
 std::cout << "Introduzca un numero: " << std::endl;
 std::cout << " NOTA: si desea salir del programa pulse 0" << std::endl;
 
 do{
   std::cout << "El numero introducido es: ";
   std::cin>> numero;
   std::cout << "El resultado es: ";
   
   std::vector <bool> vectorDeBooleanos = booleano(numero);
   
   for (int i = (vectorDeBooleanos.size()-1); i >=0; i--){ //El bit más significativo deberá quedar en la posición 0 del vector. 
                                                            //El bit más significativo es el primero de todos 
     if (vectorDeBooleanos[i] == true){
       std::cout << "1, ";
     } else {
       std::cout << "0, ";
     }
   }
   std::cout<< " " << std::endl;
 }
   
  /* for(int i = (vectorDeBooleanos.size()-1); i >= 0; i--){
     //std::cout << "El elemento " << i<< " vale: " << vectorDeBooleanos[i] 
         //<< std::endl;
     if (vectorDeBooleanos[i] == true){
       std::cout << "V, ";
     } else {
       std::cout << "F, ";
     }
   }
   std::cout<< " " << std::endl;
 }*/
 while (numero != 0);

} ////////////////////////////////////////////////////////////////////////////////////////////

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/container/set/extract&oldid=113061"