Кресты / Говнокод #29207 Ссылка на оригинал

0

  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
  11. 11
  12. 12
  13. 13
  14. 14
  15. 15
  16. 16
  17. 17
  18. 18
  19. 19
  20. 20
  21. 21
  22. 22
  23. 23
  24. 24
  25. 25
  26. 26
  27. 27
  28. 28
  29. 29
  30. 30
  31. 31
  32. 32
  33. 33
  34. 34
  35. 35
  36. 36
  37. 37
  38. 38
  39. 39
  40. 40
  41. 41
  42. 42
  43. 43
  44. 44
  45. 45
  46. 46
  47. 47
  48. 48
  49. 49
  50. 50
  51. 51
  52. 52
  53. 53
  54. 54
  55. 55
  56. 56
  57. 57
  58. 58
  59. 59
  60. 60
  61. 61
  62. 62
  63. 63
  64. 64
  65. 65
  66. 66
  67. 67
  68. 68
  69. 69
  70. 70
  71. 71
  72. 72
  73. 73
  74. 74
  75. 75
  76. 76
  77. 77
  78. 78
  79. 79
  80. 80
  81. 81
#include <iostream>
#include <type_traits>
#include <mutex>
#include <string>
#include <memory>
#include <vector>
#include <chrono>

void bad_function(void* data) {
   ///  НИКОГДА ТАК НЕ ПИШИ
    if (data) {
        std::cout << *(std::string*)data << "\n";
    }
}

template<typename T = std::string,
         typename Alloc = std::allocator<T>,
         typename = std::enable_if_t<std::is_constructible_v<T, const char*>>,
         typename Clock = std::chrono::high_resolution_clock,
         typename TimePoint = typename Clock::time_point>
class GoodFunctionImpl {
private:
    static std::recursive_mutex mtx_;
    Alloc alloc_;
    std::vector<T, Alloc> buffer_;
    std::string context_;
    TimePoint init_time_;
    
    template<typename U>
    using is_valid_type = std::conjunction<
        std::is_same<std::decay_t<U>, T>,
        std::is_constructible<T, U>
    >;
    
    void internal_log(const std::string& msg) {
        buffer_.push_back(T(msg.c_str()));
    }
    
public:
    GoodFunctionImpl() : init_time_(Clock::now()) {
        internal_log("GoodFunctionImpl initialized");
    }
    
    template<typename U,
             typename = std::enable_if_t<is_valid_type<U>::value>>
    decltype(auto) execute(U&& input) {
        std::lock_guard<std::recursive_mutex> lock(mtx_);
        
        internal_log("Processing started");
        
        T processed = std::forward<U>(input);
        
        auto duration = Clock::now() - init_time_;
        auto duration_ms = std::chrono::duration_cast<
            std::chrono::milliseconds>(duration).count();
        
        std::cout << processed << " (runtime: " 
                  << duration_ms << "ms)\n";
        
        internal_log("Processing completed");
        
        return processed;
    }
    
    size_t get_buffer_size() const { return buffer_.size(); }
};

template<typename T, typename Alloc, typename, typename Clock, typename TimePoint>
std::recursive_mutex GoodFunctionImpl<T, Alloc, Clock, TimePoint>::mtx_;

void good_function(const std::string& input) {
    // Пиши ВОТ ТАК
    // так делают все
    // это стабильно и надежно
    // так надо
    GoodFunctionImpl<> impl;
    auto result = impl.execute(input);
    
    std::cout << "Buffer entries: " 
              << impl.get_buffer_size() << "\n";
}

Запостил: lisp-worst-code lisp-worst-code, (Updated )

Комментарии (8) RSS

  • ava guest # 0

    ну как-бы отключать статическую проверку типов и правда идея так себе
    Ответить

  • ava guest # 0

    template<typename T>
    concept бро_культурнонеполучитсяитд = std::is_constructible_v<T, const char*>;
    ПИШИ ВОТ ТАК

    typename = std::enable_if_t<std::is_constructible_v<T, const char*>> НИКОГДА ТАК НЕ ПИШИ
    Ответить

    • ava guest # 0 ⇈

      хуясе ты концепты уже используешь, а люди вон только открыли для себя, что кастить указатель на войн в случайную хуйню не нужно.

      собссно, в этом вопросе они обскакали моих коллег.Им совсем не очевидно почему кастить не нужно (кроме случаев sealed классов и исчерпывающего паттерн матченга)
      Ответить

      • ava OPAHrymaH # Ссылка на оригинал 0 ⇈

        Конь-цепты в крестах — это типа предикатов в языке Ада?
        Ответить

        • ava MAKAKA # Ссылка на оригинал 0 ⇈

          Это статичечечки проверяемые хуйни.

          Традиционно в крестах проверять тип во время компиляции можно было только для виритуальной хуйни. Но виртуальная хуйня стоит времени, потому шоблоёбло в std ее не использует (про это явно писал страус)

          Так что стдлиб была, по сути, петушиной типизацией, и можно было случайно удалить напрмиер копроивание, и вот твой объект в коллекцию уже не влазит, и ты получаеш стену текста раскрытых шаблрнов, и если там у тебя VC 6.0, то удачи тебе понять что там не так раскрылось

          Говорят, соврменные копуляторы стали чуть менее говноедскими, но удовольствия мало.

          Концепты позволяют сказать: я не принимают петуха который не тривиали копабыл, и всё: вот упадет прямо тут с криком, что он не триваили копабыл.

          По крайней мере я так их понял.

          В расте сделано хорошо: там ты можешь заказать трейт для щаблона, а реализоввать ты его можешь динамически (через таблицу врот-уральных методов) а можешь и статически, и тогда шабло мономорфируется
          Ответить

  • ava ISO # Ссылка на оригинал 0

    Совершенно верно, так писать не стоит. Исправил.
    void good_function(void* data) {
    if (data) {
        std::cout << *reinterpret_cast<std::string*>(data) << "\n";
    }
}
    Ответить

    • ava guest # 0 ⇈

      Ты бы влился в наш коллектив. У нас тоже принято писать
      fun doAll(foo:Any) {
 if (foo is Petuzik){...}
 else if (foo is Koorochka){...}
 else 
}
      Ответить

    • ava guest # 0 ⇈

      Или вот случай был: один ламер написал
      void good_function(void* data) {
    if (data) {
        std::cout << (std::string*)data << "\n";
    }
}


      ну разумеется опытные программисты сразу же исправили, и написали как ты написал выше. Потому что надежность -- самое главное!
      Ответить

Добавить комментарий

Где здесь C++, guest?!

    А не использовать ли нам bbcode?

    ↑
    8
    ↓