Selector aleatorio -- ++ campo con template-meta-programming campo con c++17 camp codereview Relacionados El problema

Random selector


2
vote

problema

Español

Descripción general:

El objeto del tipo random_selector actúa como un objeto de función y elija aleatoriamente un elemento de la secuencia especificada. La longitud de la secuencia se infiere automáticamente. También se proporcionan algunas funciones de miembro de conveniencia. Está destinado a ser parte de mi marco de referencia V2.

Código:

  #ifndef AREA51_RANDOM_SELECTOR_HPP #define AREA51_RANDOM_SELECTOR_HPP  #include "random_int_generator.hpp" #include "utilities.hpp"  #include <vector> #include <utility> #include <iterator> #include <stdexcept>  template <typename T,         typename RandomNumberGenerator = shino::random_int_generator<std::size_t>> class random_selector {     std::vector<T> pool;     RandomNumberGenerator rng; public:     using value_type = std::add_const_t<T>;     using reference = value_type&;     using iterator = typename std::vector<T>::const_iterator;      template <typename InputIt>     random_selector(InputIt first, InputIt last):             pool(first, last),             rng(0, pool.size() - 1)     {         if (pool.size() == 0)         {             throw std::invalid_argument("Range cannot be empty");         }     }      random_selector(std::initializer_list<T> init_list):             pool(init_list),             rng(0, init_list.size() - 1)     {         if (pool.size() == 0)         {             throw std::invalid_argument("Range cannot be empty");         }     }      //let T and RandomNumberGenerator decide on rule of 5      reference operator()()     {         return pool[rng()];     }      template <typename OutputIt>     void operator()(OutputIt first, OutputIt last)     {         while (first != last)         {             *first++ = pool[rng()];         }     }      //sfinae friendly reset     //Q stands for Qualified     template <typename QRandomNumberGenerator,             typename = shino::enable_sfinae<QRandomNumberGenerator,                     RandomNumberGenerator>>     void reset_generator(QRandomNumberGenerator&& next_rng)     {         rng = next_rng;     }      std::size_t data_size()     {         return pool.size();     }      iterator begin()     {         return pool.cbegin();     }      iterator end()     {         return pool.cend();     } };  #endif //AREA51_RANDOM_SELECTOR_HPP   

Demo:

  #include "../src/random_selector.hpp" #include <string> #include <iostream>  int main() {     random_selector<std::string> selector({"Marzhan", "David", "Jack", "Aisulu", "Darkhan", "Akbota"});      for (const auto& name: selector)     {         std::cout << name << ", ";     }     std::cout << " "               "Choosing 10 random names from pool: ";      for (int i = 0; i < 10; ++i)     {         const std::string& current_name = selector();         std::cout << current_name << ", ";     } }   

Salida:

Marzhan, David, Jack, Aisulu, Darkhan, Akbota,

Elegir 10 nombres aleatorios de la piscina:

Darkhan, Marzhan, Jack, Darkhan, David, Darkhan, Jack, David, Marzhan, Aisulu,

Requisitos:

ON EN TIPO T :

  • lo que sea std::vector<T> requiere

on tipo RandomNumberGenerator :

  • Tener constructor que acepte pares de números, $ A $ y $ B $ que le dice al objeto que genere números solo en el rango $ [A; B] $.

    < / li>
  • operator() que emite datos implícitamente convertibles a std::size_t . El rango debe corresponde a $ [a; b] $ en la llamada constructor.

  • destructible

Funciones:

  • El rango de entrada vacío en la llamada constructor está prohibida. Si la implementación podrá detectarla, el constructor lanzará std::invalid_argument o su derivado. Es seguro asumir que 9988777665544339 se imitará. (Esto me dará alguna sala de respiración en los detalles de la implementación).

Decisiones de diseño:

  • rn rng: Por lo general, uso una envoltura sobre el generador y la distribución, así que no me importa. Puede estar en el futuro, tendré un objeto de distribución diferente, por lo que quiero tener ambos herméticamente acoplados.

  • Elementos inmutables: No puedo encontrar ningún caso al modificar los elementos no sería un error. Puede ser un grupo de generadores aleatorios, pero eso suena raro en el mejor de los casos.

  • sfinae en el generador de restablecimiento: la primera razón es obvia. Segundo: Recuerdo que había un problema con las referencias universales, pero desde hace mucho tiempo, desde hace tiempo olvidé lo que era el problema. Solo se convirtió en un hábito.

  • Pocos constructores: la implementación de otros impondrían requisitos más complejos en #ifndef AREA51_RANDOM_SELECTOR_HPP #define AREA51_RANDOM_SELECTOR_HPP #include "random_int_generator.hpp" #include "utilities.hpp" #include <vector> #include <utility> #include <iterator> #include <stdexcept> template <typename T, typename RandomNumberGenerator = shino::random_int_generator<std::size_t>> class random_selector { std::vector<T> pool; RandomNumberGenerator rng; public: using value_type = std::add_const_t<T>; using reference = value_type&; using iterator = typename std::vector<T>::const_iterator; template <typename InputIt> random_selector(InputIt first, InputIt last): pool(first, last), rng(0, pool.size() - 1) { if (pool.size() == 0) { throw std::invalid_argument("Range cannot be empty"); } } random_selector(std::initializer_list<T> init_list): pool(init_list), rng(0, init_list.size() - 1) { if (pool.size() == 0) { throw std::invalid_argument("Range cannot be empty"); } } //let T and RandomNumberGenerator decide on rule of 5 reference operator()() { return pool[rng()]; } template <typename OutputIt> void operator()(OutputIt first, OutputIt last) { while (first != last) { *first++ = pool[rng()]; } } //sfinae friendly reset //Q stands for Qualified template <typename QRandomNumberGenerator, typename = shino::enable_sfinae<QRandomNumberGenerator, RandomNumberGenerator>> void reset_generator(QRandomNumberGenerator&& next_rng) { rng = next_rng; } std::size_t data_size() { return pool.size(); } iterator begin() { return pool.cbegin(); } iterator end() { return pool.cend(); } }; #endif //AREA51_RANDOM_SELECTOR_HPP 0 , por lo que decidí delegar en 99887776655443311 .

  • .

critique Solicitud:

Siéntase libre de comentar algo. Mi principal preocupación es dejar la regla de 5 a #ifndef AREA51_RANDOM_SELECTOR_HPP #define AREA51_RANDOM_SELECTOR_HPP #include "random_int_generator.hpp" #include "utilities.hpp" #include <vector> #include <utility> #include <iterator> #include <stdexcept> template <typename T, typename RandomNumberGenerator = shino::random_int_generator<std::size_t>> class random_selector { std::vector<T> pool; RandomNumberGenerator rng; public: using value_type = std::add_const_t<T>; using reference = value_type&; using iterator = typename std::vector<T>::const_iterator; template <typename InputIt> random_selector(InputIt first, InputIt last): pool(first, last), rng(0, pool.size() - 1) { if (pool.size() == 0) { throw std::invalid_argument("Range cannot be empty"); } } random_selector(std::initializer_list<T> init_list): pool(init_list), rng(0, init_list.size() - 1) { if (pool.size() == 0) { throw std::invalid_argument("Range cannot be empty"); } } //let T and RandomNumberGenerator decide on rule of 5 reference operator()() { return pool[rng()]; } template <typename OutputIt> void operator()(OutputIt first, OutputIt last) { while (first != last) { *first++ = pool[rng()]; } } //sfinae friendly reset //Q stands for Qualified template <typename QRandomNumberGenerator, typename = shino::enable_sfinae<QRandomNumberGenerator, RandomNumberGenerator>> void reset_generator(QRandomNumberGenerator&& next_rng) { rng = next_rng; } std::size_t data_size() { return pool.size(); } iterator begin() { return pool.cbegin(); } iterator end() { return pool.cend(); } }; #endif //AREA51_RANDOM_SELECTOR_HPP 2 #ifndef AREA51_RANDOM_SELECTOR_HPP #define AREA51_RANDOM_SELECTOR_HPP #include "random_int_generator.hpp" #include "utilities.hpp" #include <vector> #include <utility> #include <iterator> #include <stdexcept> template <typename T, typename RandomNumberGenerator = shino::random_int_generator<std::size_t>> class random_selector { std::vector<T> pool; RandomNumberGenerator rng; public: using value_type = std::add_const_t<T>; using reference = value_type&; using iterator = typename std::vector<T>::const_iterator; template <typename InputIt> random_selector(InputIt first, InputIt last): pool(first, last), rng(0, pool.size() - 1) { if (pool.size() == 0) { throw std::invalid_argument("Range cannot be empty"); } } random_selector(std::initializer_list<T> init_list): pool(init_list), rng(0, init_list.size() - 1) { if (pool.size() == 0) { throw std::invalid_argument("Range cannot be empty"); } } //let T and RandomNumberGenerator decide on rule of 5 reference operator()() { return pool[rng()]; } template <typename OutputIt> void operator()(OutputIt first, OutputIt last) { while (first != last) { *first++ = pool[rng()]; } } //sfinae friendly reset //Q stands for Qualified template <typename QRandomNumberGenerator, typename = shino::enable_sfinae<QRandomNumberGenerator, RandomNumberGenerator>> void reset_generator(QRandomNumberGenerator&& next_rng) { rng = next_rng; } std::size_t data_size() { return pool.size(); } iterator begin() { return pool.cbegin(); } iterator end() { return pool.cend(); } }; #endif //AREA51_RANDOM_SELECTOR_HPP 3 , pero no pude implementar el constructor de movimiento amigable de Sfinae, así que lo dejó como es.

cosas necesarias para ejecutar la demostración:

El siguiente código no pretende ser parte de la publicación de revisión, pero si tiene alguna idea, no dude en comentarlo también:

random_int_generator.hpp:

  #ifndef AREA51_RANDOM_SELECTOR_HPP #define AREA51_RANDOM_SELECTOR_HPP  #include "random_int_generator.hpp" #include "utilities.hpp"  #include <vector> #include <utility> #include <iterator> #include <stdexcept>  template <typename T,         typename RandomNumberGenerator = shino::random_int_generator<std::size_t>> class random_selector {     std::vector<T> pool;     RandomNumberGenerator rng; public:     using value_type = std::add_const_t<T>;     using reference = value_type&;     using iterator = typename std::vector<T>::const_iterator;      template <typename InputIt>     random_selector(InputIt first, InputIt last):             pool(first, last),             rng(0, pool.size() - 1)     {         if (pool.size() == 0)         {             throw std::invalid_argument("Range cannot be empty");         }     }      random_selector(std::initializer_list<T> init_list):             pool(init_list),             rng(0, init_list.size() - 1)     {         if (pool.size() == 0)         {             throw std::invalid_argument("Range cannot be empty");         }     }      //let T and RandomNumberGenerator decide on rule of 5      reference operator()()     {         return pool[rng()];     }      template <typename OutputIt>     void operator()(OutputIt first, OutputIt last)     {         while (first != last)         {             *first++ = pool[rng()];         }     }      //sfinae friendly reset     //Q stands for Qualified     template <typename QRandomNumberGenerator,             typename = shino::enable_sfinae<QRandomNumberGenerator,                     RandomNumberGenerator>>     void reset_generator(QRandomNumberGenerator&& next_rng)     {         rng = next_rng;     }      std::size_t data_size()     {         return pool.size();     }      iterator begin()     {         return pool.cbegin();     }      iterator end()     {         return pool.cend();     } };  #endif //AREA51_RANDOM_SELECTOR_HPP 4  

Extripto de Utilities.HPP:

  #ifndef AREA51_RANDOM_SELECTOR_HPP #define AREA51_RANDOM_SELECTOR_HPP  #include "random_int_generator.hpp" #include "utilities.hpp"  #include <vector> #include <utility> #include <iterator> #include <stdexcept>  template <typename T,         typename RandomNumberGenerator = shino::random_int_generator<std::size_t>> class random_selector {     std::vector<T> pool;     RandomNumberGenerator rng; public:     using value_type = std::add_const_t<T>;     using reference = value_type&;     using iterator = typename std::vector<T>::const_iterator;      template <typename InputIt>     random_selector(InputIt first, InputIt last):             pool(first, last),             rng(0, pool.size() - 1)     {         if (pool.size() == 0)         {             throw std::invalid_argument("Range cannot be empty");         }     }      random_selector(std::initializer_list<T> init_list):             pool(init_list),             rng(0, init_list.size() - 1)     {         if (pool.size() == 0)         {             throw std::invalid_argument("Range cannot be empty");         }     }      //let T and RandomNumberGenerator decide on rule of 5      reference operator()()     {         return pool[rng()];     }      template <typename OutputIt>     void operator()(OutputIt first, OutputIt last)     {         while (first != last)         {             *first++ = pool[rng()];         }     }      //sfinae friendly reset     //Q stands for Qualified     template <typename QRandomNumberGenerator,             typename = shino::enable_sfinae<QRandomNumberGenerator,                     RandomNumberGenerator>>     void reset_generator(QRandomNumberGenerator&& next_rng)     {         rng = next_rng;     }      std::size_t data_size()     {         return pool.size();     }      iterator begin()     {         return pool.cbegin();     }      iterator end()     {         return pool.cend();     } };  #endif //AREA51_RANDOM_SELECTOR_HPP 5  
Original en ingles

Overview:

The object of the type random_selector acts as a function object and randomly choose one element from the specified sequence. Length of the sequence is inferred automatically. Also some convenience member functions are provided. It is meant to be a part of my benchmark v2 framework.

Code:

#ifndef AREA51_RANDOM_SELECTOR_HPP #define AREA51_RANDOM_SELECTOR_HPP  #include "random_int_generator.hpp" #include "utilities.hpp"  #include <vector> #include <utility> #include <iterator> #include <stdexcept>  template <typename T,         typename RandomNumberGenerator = shino::random_int_generator<std::size_t>> class random_selector {     std::vector<T> pool;     RandomNumberGenerator rng; public:     using value_type = std::add_const_t<T>;     using reference = value_type&;     using iterator = typename std::vector<T>::const_iterator;      template <typename InputIt>     random_selector(InputIt first, InputIt last):             pool(first, last),             rng(0, pool.size() - 1)     {         if (pool.size() == 0)         {             throw std::invalid_argument("Range cannot be empty");         }     }      random_selector(std::initializer_list<T> init_list):             pool(init_list),             rng(0, init_list.size() - 1)     {         if (pool.size() == 0)         {             throw std::invalid_argument("Range cannot be empty");         }     }      //let T and RandomNumberGenerator decide on rule of 5      reference operator()()     {         return pool[rng()];     }      template <typename OutputIt>     void operator()(OutputIt first, OutputIt last)     {         while (first != last)         {             *first++ = pool[rng()];         }     }      //sfinae friendly reset     //Q stands for Qualified     template <typename QRandomNumberGenerator,             typename = shino::enable_sfinae<QRandomNumberGenerator,                     RandomNumberGenerator>>     void reset_generator(QRandomNumberGenerator&& next_rng)     {         rng = next_rng;     }      std::size_t data_size()     {         return pool.size();     }      iterator begin()     {         return pool.cbegin();     }      iterator end()     {         return pool.cend();     } };  #endif //AREA51_RANDOM_SELECTOR_HPP 

Demo:

#include "../src/random_selector.hpp" #include <string> #include <iostream>  int main() {     random_selector<std::string> selector({"Marzhan", "David", "Jack", "Aisulu", "Darkhan", "Akbota"});      for (const auto& name: selector)     {         std::cout << name << ", ";     }     std::cout << "\n"               "Choosing 10 random names from pool:\n";      for (int i = 0; i < 10; ++i)     {         const std::string& current_name = selector();         std::cout << current_name << ", ";     } } 

Output:

Marzhan, David, Jack, Aisulu, Darkhan, Akbota,

Choosing 10 random names from pool:

Darkhan, Marzhan, Jack, Darkhan, David, Darkhan, Jack, David, Marzhan, Aisulu,

Requirements:

on type T:

  • Whatever std::vector<T> requires

on type RandomNumberGenerator:

  • Have constructor that accepts pair of numbers, \$a\$ and \$b\$ that tells the object to generate numbers only in range \$[a;b]\$.

  • operator() that outputs data implicitly convertible to std::size_t. Range must correspond to \$[a;b]\$ in the constructor call.

  • Destructible

Functions:

  • Empty input range on constructor call is prohibited. If the implementation will be able to detect it, the constructor will throw std::invalid_argument or its derivative. It is safe to assume that std::distance() will be mimicked. (This will give me some breathing room in implementation details).

Design decisions:

  • Weird RNG: I usually use a wrapper over the generator and distribution, so I don't care about it. May be in the future I'll have different distribution object, so I want to have both tightly coupled.

  • Immutable elements: I can't come up with any case when modifying elements wouldn't be an error. May be a pool of random generators could, but that sounds weird at best.

  • SFINAE on reset generator: first reason is obvious. Second: I remember there was a problem with universal references, but I've long since forgotten what the problem was. It just turned into a habit.

  • Few constructors: implementing other ones would impose more complex requirements on T, so I decided to delegate to std::vector<T>.

Critique request:

Feel free to comment on anything. My major concern is leaving rule of 5 to T and RandomNumberGenerator, but I couldn't implement SFINAE friendly move constructor, so left it as it is.

Necessary stuff to run the demo:

The following code is not intended to be part of the review post, but if you have any thoughts feel free to comment on those as well:

random_int_generator.hpp:

#ifndef RANDOM_ENGINE_HPP #define RANDOM_ENGINE_HPP  #include <random> #include <memory> #include <type_traits> #include <utility>  template <typename T> inline constexpr bool is_integer_type = std::is_integral_v<T>;  namespace shino {     template<typename IntegerType = int, typename RandomNumberEngine = std::mt19937_64>     class random_int_generator {         std::unique_ptr<RandomNumberEngine> engine;         std::uniform_int_distribution<IntegerType> dist;     public:         template <typename ... Ts>         random_int_generator(IntegerType first = 0,                              IntegerType last = std::numeric_limits<IntegerType>::max(),                              Ts&& ... args):                 engine(std::make_unique<RandomNumberEngine>(std::forward<Ts>(args)...)),                 dist(first, last)         {}          //allow move construction since it is disabled by deleted copy constructor         random_int_generator(random_int_generator&& other) = default;          void range(IntegerType first,                    IntegerType last = std::numeric_limits<IntegerType>::max())         {             dist = std::uniform_int_distribution<IntegerType>(first, last);         }          std::pair<IntegerType, IntegerType>         range()         {             return {dist.a(), dist.b()};         };          template<typename OutputIt>         void operator()(OutputIt first, OutputIt last)         {             while (first != last) {                 *first++ = dist(*engine);             }         }          IntegerType operator()() {             return dist(*engine);         }          /*          * Providing const versions doesn't make sense because          * it is impossible to do anything meaningful with          * const random int generator          * */         RandomNumberEngine& get_engine()         {             return *engine;         }          std::uniform_int_distribution<IntegerType>&         get_distribution()         {             return dist;         }     }; }  #endif 

excerpt from utilities.hpp:

template <typename QualifiedType, typename OriginalType> using enable_sfinae = std::enable_if_t<std::is_same_v<std::decay_t<QualifiedType>, OriginalType>>; 
        
       
       

Lista de respuestas

3
 
vote
vote
La mejor respuesta
 

Aquí hay algunos comentarios generales:

  1. list_of_days[index+1]4 no tiene un destructor virtual, lo que probablemente significa que no necesita / desea que alguien heredó de él. Es que es el caso, marquelo como list_of_days[index+1]5 (si no, proporcione un destructor virtual):

      list_of_days[index+1]6  
  2. No parece que lo use para modificar list_of_days[index+1]7 . ¿Por qué no marcarlo como list_of_days[index+1]8 ?

  3. Funciones de marca que no lanzan list_of_days[index+1]9 .
  4. Algunas funciones (como if0 , if1 , 99887766555443322 , ...) No tiene ninguna razón para no ser llamados cuando el selector es if3 . Marquelos como if4 :

      if5  
  5. Aproveche el hecho de que if6 proporciona if7 y if8 Funciones para implementar un constructor en términos de otro (que es una buena práctica, evita la duplicación):

      if9  
  6. Hubiera usado var $this = $(this);0 en lugar de ese bucle rodado a mano:

      var $this = $(this);11  
  7. Uso var $this = $(this);2 en lugar de var $this = $(this);3 .

  8. En lugar de construir el generador con el rango como argumentos, pasaría el rango al llamar al generador. También pasaría el rango como un argumento constructor. Esto tiene 2 ventajas:

    • Puede aprobar bien una lambda:

        var $this = $(this);4  
    • Puede pasar una función, en lugar de un objeto de función.

  9. que está nombrando es un poco engañoso: var $this = $(this);55 es un var $this = $(this);6 y var $this = $(this);77 es var $this = $(this);38 . Considere cambiarlos a var $this = $(this);9 y .prop({ disabled: true, title: 'Readonly.' }); 0 respectivamente.

 

Here are some general comments:

  1. random_selector doesn't have a virtual destructor, which probably means you don't need/want someone to inherit from it. It that it the case, mark it as final (if not, provide a virtual destructor):

    // ... class random_selector final // ... 
  2. You don't seem to use to modify pool. Why not mark it as const?

  3. Mark functions that don't throw noexcept.
  4. Some functions (like data_size, begin, end, ...) have no reason not to be called when the selector is const. Mark them as const:

    const random_selector rs;  // std::size_t data_size(); rs.data_size(); // illegal  // std::size_t data_size() const noexcept rs.data_size(); // legal (noexcept because it doesn't throw) 
  5. Leverage the fact that std::initializer_list provides begin and end functions to implement a constructor in terms of another (which is good practice - avoids duplication):

    random_selector(std::initializer_list<T> init_list) :        random_selector(init_list.begin(), init_list.end()) {} 
  6. I would have used std::generate instead of that hand rolled loop:

    std::generate(first, last, [&rng, &pool]() {     return pool[rng()]; });  
  7. Use std::vector::empty instead of std::vector::size() == 0.

  8. Instead of constructing the generator with the range as arguments, I would pass the range when calling the generator. I would also pass the range as a constructor argument. This has 2 advantages:

    • You can nicely pass a lambda:

      random_selector selector{ { 1, 2, 3 }, [](int min, int max) { return 42; } }; 
    • You can pass a function, instead of a function object.

  9. You're naming is a bit misleading: reference is a const& and iterator is const. Consider changing them to const_reference and const_iterator respectively.

 
 
 
 
3
 
vote

static_assert() y <type_traits> podría documentar al menos algunos de sus requisitos, lo que resulta en mensajes más claros de tiempo de compilación.

C ++ 17 parece contar con std::sample . Solo mencionando

últimamente estoy harto de constilitud, por lo que esto podría ser sesgado. Más const ! Por ejemplo, const std::vector<T> pool; .

 

static_assert() and <type_traits>could document at least some of your requirements, resulting in clearer compile-time messages.

C++17 seems to feature std::sample. Just mentioning.

Lately I am sick of Constilness, so this might be biased. More const! For example const std::vector<T> pool;.

 
 

Relacionados problema

3  Eliminación de variables genéricos con múltiples puntos de entrada  ( Generic variable elimination with multiple entry points ) 
Tengo este algoritmo, llamado eliminación variable , que se usa con bastante frecuencia en mi código -Base (biblioteca). Es un algoritmo para los gráficos de...

5  C ++ Elija entre funciones de implementación de tiempo de ejecución y tiempo de compilación  ( C choose between runtime and compile time implementation functions ) 
Escribí una pequeña función de envoltura para elegir entre Tiempo de ejecución (STD) 99887766555443318 y una versión de ConsexPR, como continuación de la cl...

2  "Multi" Guardia de alcance que usa la característica de Deducación de la plantilla  ( Multi scope guard using template argument deducing feature ) 
Uso de la función C ++ moderna Deducción del argumento de la plantilla para las plantillas de clase y Expresiones plegables Es posible implementar la...

5  Leetcode 928: Minimice Malware Spread II  ( Leetcode 928 minimize malware spread ii ) 
Estoy publicando mi código para un problema de código leetcode. Si desea revisar, por favor hágalo. ¡Gracias por su tiempo! Problema (este problema es el ...

5  Clase de registro de C ++  ( C logging class ) 
He creado una clase simple de registro de C ++. Produce varios loglas, y ajusta el color de la salida en consecuencia. Estoy interesado en cualquier consejo p...

2  Fusionar ocurrencias adyacentes de elementos idénticos en la recopilación de datos  ( Merge adjacent occurrences of identical elements in data collection ) 
Hay una pequeña Ejercicio de programación para fusionar elementos idénticos adyacentes en una colección. Aquí hay dos soluciones (Pasando las pruebas de...

4  Implementar el servidor HTTP utilizando libevent  ( Implement http server using libevent ) 
#include "fmt/format.h" #include <cstdint> #include <cstdio> #include <event2/event-config.h> #include <event2/util.h> #include <evhttp.h> #include <memory> ...

20  Cree una cadena C ++ usando el formato de estilo de impresión  ( Create a c string using printf style formatting ) 
A menudo es conveniente usar cadenas de formato C-Style 998877766554433665544336 A menudo encuentro los modificadores mucho más sencillos para usar que los...

3  Implementar el rango de Fibonacci  ( Implement fibonacci range ) 
Estoy implementando una gama FIBONACCI en C ++ 17 de tal manera que admite #include "fib.h" #include <iostream> int main() { for (int x : Fibonacci())...

8  Conversión de STD :: Chrono :: Time_Point to / from std :: string  ( Converting stdchronotime point to from stdstring ) 
Considere estas funciones que permitan convertir checkOnline.sh4 a / FROM checkOnline.sh5 Con un formato Fecha de fecha ". checkOnline.sh6 con uso:...




© 2022 respuesta.top Reservados todos los derechos. Centro de preguntas y respuestas reservados todos los derechos