1. C++ / Говнокод #28326

    +2

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    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
    82. 82
    83. 83
    84. 84
    85. 85
    86. 86
    87. 87
    88. 88
    89. 89
    90. 90
    91. 91
    92. 92
    93. 93
    94. 94
    95. 95
    96. 96
    97. 97
    98. 98
    99. 99
    #include <stddef.h>
    #include <stdio.h>
    #include <utility>
    #define PLACEHOLDER char x[0];
    
    #define FORCEINLINE 
    template <typename T, typename... Ts> struct MyTuple : MyTuple<Ts...>
    {
    	FORCEINLINE constexpr MyTuple(T&& t, Ts&&... ts)
    		: value(std::move(t))
    		, MyTuple<Ts...> (std::forward<Ts>(ts)...){}
    	FORCEINLINE explicit MyTuple(const MyTuple<T,Ts...> &other) = default;
    	FORCEINLINE MyTuple(MyTuple<T,Ts...> &&other)
    		: MyTuple<Ts...>(std::forward<MyTuple<Ts...>>(other)),
    		value(std::move(other.value)){}
    
    	FORCEINLINE constexpr int size() const { return 1 + MyTuple<Ts...>::size(); }
    	constexpr static int sz = 1 + MyTuple<Ts...>::sz;
    	FORCEINLINE MyTuple<Ts...> &next(){return *static_cast<MyTuple<Ts...>*>(this);}
    	using tnext = MyTuple<Ts...>;
    	T value;
    	FORCEINLINE ~MyTuple() {}
    	constexpr static bool isitem = false;
    };
    struct MyTupleEmpty
    {
    	PLACEHOLDER
    	FORCEINLINE constexpr int size() const { return 0; }
    	static constexpr int sz = 0;
    	~MyTupleEmpty() {}
    	constexpr static bool isitem = false;
    };
    
    template <typename T> struct MyTuple<T> {
    	FORCEINLINE MyTuple(T&& t) : value(std::move(t)){}
    	FORCEINLINE explicit MyTuple(const MyTuple<T> &other) = default;
    	FORCEINLINE MyTuple(MyTuple<T> &&other): value(std::move(other.value)){}
    
    	FORCEINLINE MyTupleEmpty &next() const{
    		static MyTupleEmpty empty;
    		return empty;
    	}
    	FORCEINLINE constexpr int size() const { return 1; }
    	constexpr static int sz = 1;
    	using tnext =MyTupleEmpty;
    	T value;
    	FORCEINLINE ~MyTuple() {}
    	constexpr static bool isitem = false;
    };
    template <class T>struct unwrap_refwrapper{using type = T;};
    template <class T>struct unwrap_refwrapper<std::reference_wrapper<T>>{using type = T&;};
     template <class T> using unwrap_decay_t = typename unwrap_refwrapper<typename std::decay<T>::type>::type;
    template<typename... Ts>
    static FORCEINLINE MyTuple<unwrap_decay_t<Ts>...> MakeTuple(Ts&&... args)
    {
    	return MyTuple<unwrap_decay_t<Ts>...>(std::forward<Ts>(args)...);
    }
    struct i3{
        auto setProp(auto x, i3 t = *(i3*)0)
        {
            typename decltype(x(*this))::tp c;
            return c;
        }
        using tp = i3;
    };
    
    
    #define s(x,y) setProp([](auto c){struct xxx: decltype(c)::tp{decltype(y) x = y;using tp = xxx;    decltype([] (auto xx, xxx &t = *(xxx*)0)\
        {\
            typename decltype(xx(t))::tp c;\
            return c;\
        }) setProp;auto BeginChildren(){return *this;}} d;return d;})
    
    #define c(...) BeginChildren(),MakeTuple(__VA_ARGS__)
    #define i(...) i3()
    
    
    
    
    void func2()
    {
        auto tp = MakeTuple(
        i(Window)
            .s(width,10)
            .s(height,20)
            .c(
                i(Item),
                i(Item2)
                    .s(property1,10.0f)
    
            )
        );
        printf("%d %d %f\n",tp.value.height,tp.value.width, tp.next().value.next().value.property1);
    }
    
    int main()
    {
        func2();
    }

    qml-like структура в compile time
    Стандартизаторы всё пытались запретить шаблоны в локальных классах, да не вышло - понаоставляли дыр в лямбдах и decltype.
    Если добавить -fpermissive, то gcc сожрёт даже с constexpr

    mittorn, 09 Августа 2022

    Комментарии (19)
  2. C++ / Говнокод #28319

    −1

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    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
    AnsiString str = IntToHex((__int64) longvalue, 2); // 0x01020304
    
        char _c[11];
        char *ch = str.c_str();
        int len = strlen(ch);
        int _s = len;
        int j = 0;
        _c[j++] = '0';
        _c[j++] = 'x';
        while (_s >= 2) {
            _c[j++] = ch[_s-2];
            _c[j++] = ch[_s-1];
            _s-=2;
        }
        if (len == 7) {
            _c[j++] = '0';
            _c[j] = ch[0];
        }
        _c[10] = '\0';
    
        unsigned long pp;
        char *pEnd;
        pp = strtoul (_c, &pEnd, 16); // 0x04030201 - PROFIT!

    Наслаждайтесь

    FataLL, 05 Августа 2022

    Комментарии (266)
  3. C++ / Говнокод #28318

    +3

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    AnsiString Cut_the_path(AnsiString ExeName)
    {
        AnsiString Path = ExeName;
        char *cp = Path.c_str(); int last = Path.Length()-1;
        int i=last;
        for(; i>=0; i--)
        {
            if( *(cp+i) == '\\' )
                break;
            Path.Delete(Path.Length(),1);
        }
        return Path;
    }

    FataLL, 04 Августа 2022

    Комментарии (151)
  4. C++ / Говнокод #28313

    +3

    1. 1
    2. 2
    3. 3
    } catch (...) {
        // ¯\_(ツ)_/¯
    }

    Ну заебись комментарий

    3_dar, 02 Августа 2022

    Комментарии (3)
  5. C++ / Говнокод #28299

    −1

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    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
    82. 82
    83. 83
    84. 84
    85. 85
    86. 86
    87. 87
    88. 88
    89. 89
    90. 90
    91. 91
    92. 92
    #include <iostream>
    #include <string>
    #include <thread>
    #include <mutex>
    #include <condition_variable>
    #include <atomic>
    #include <queue>
    
    
    std::condition_variable messages_cv;
    std::mutex messages_mtx;
    std::queue<std::string> messages;
    
    std::atomic_bool running = true; // TODO: stop_token when c++20
    
    
    void pull_messages_thread() {
        bool should_run = running;
        while (should_run) {
            std::unique_lock lock(messages_mtx);
        
            messages_cv.wait(lock, []{ return !messages.empty() || !running; });
            if (messages.empty()) return;
        
            auto message = std::move(messages.front());
            messages.pop();
        
            should_run = running || !messages.empty();
            lock.unlock();
        
            std::cout << "Processing\t" + message + "\n";
            std::this_thread::sleep_for(std::chrono::milliseconds(20));
            std::cout << "Processed\t" + message + "\n";
        }
    }
    
    
    int main() {
        std::thread puller(pull_messages_thread);
        for (std::size_t i = 0; i < 10; ++i) {
            std::string message = "Message<" + std::to_string(i) + ">";
    
            std::unique_lock lock(messages_mtx);
            std::cout << "Storing \t" + message + "\n";
            messages.emplace(std::move(message));
            lock.unlock();
            messages_cv.notify_all();
    
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
        }
    
        // std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    
        running = false;
        messages_cv.notify_all();
        puller.join();
    }
    
    /*
    
    Storing 	Message<0>
    Processing	Message<0>
    Storing 	Message<1>
    Storing 	Message<2>
    Processed	Message<0>
    Processing	Message<1>
    Storing 	Message<3>
    Processed	Message<1>
    Processing	Message<2>
    Storing 	Message<4>
    Storing 	Message<5>
    Processed	Message<2>
    Processing	Message<3>
    Storing 	Message<6>
    Storing 	Message<7>
    Processed	Message<3>
    Processing	Message<4>
    Storing 	Message<8>
    Storing 	Message<9>
    Processed	Message<4>
    Processing	Message<5>
    Processed	Message<5>
    Processing	Message<6>
    Processed	Message<6>
    Processing	Message<7>
    Processed	Message<7>
    Processing	Message<8>
    Processed	Message<8>
    Processing	Message<9>
    Processed	Message<9>
    
     */

    grillow1337, 27 Июля 2022

    Комментарии (0)
  6. C++ / Говнокод #28280

    −1

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    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
    82. 82
    83. 83
    84. 84
    85. 85
    #include <iostream>
    
    // Truthiness
    struct true_type{static const bool value = true;};
    struct false_type{ static const bool value = false;};
    
    // Pick type based on bool value
    template <bool B, typename T, typename U>struct conditional{typedef T type;};
    template <typename T, typename U>struct conditional<false, T, U>{typedef U type;};
    
    // Compare two types
    template <typename T, typename U>struct is_same : public false_type{};
    template <typename T>struct is_same<T, T> : public true_type{};
    
    // Division predicate
    template <int a, int b>struct divides{static const bool value = (a % b == 0);};
    
    // Type traits
    template <typename T, int N = 0>
    struct fizzbuzz_traits{
    	typedef T type;
    	static const  int value = N;
    };
    
    template <> struct fizzbuzz_traits<char*, 0>{typedef char* type;};
    
    // fizzbuzz type initializers
    template <bool A, bool B> struct fizzbuzz{};
    
    template <> struct fizzbuzz<true, false> : public fizzbuzz_traits<char*> {static const char* value;};
    typedef fizzbuzz<true, false> fizz_type;
    const char* fizz_type::value = "fizz";      // static const char* can only be initialized out of line
    
    template <> struct fizzbuzz<true, true> : public fizzbuzz_traits<char*> {static const char* value;};
    typedef fizzbuzz<true, true> fizzbuzz_type;
    const char *fizzbuzz_type::value = "fizzbuzz"; 
    
    template <> struct fizzbuzz<false, true> : public fizzbuzz_traits<char*> {static const char* value;};
    typedef fizzbuzz<false, true> buzz_type;
    const char *buzz_type::value = "buzz";
    
    template <> struct fizzbuzz<false, false> : fizzbuzz_traits<void>{};
    
    
    // FizzBuzz solver
    template <int N>
    class FizzBuzz{
    private:
    	struct is_divisible : public true_type{
        
    		struct by3 : public divides<N, 3>{};
    		struct by5 : public divides<N, 5>{};
    	};
    public:
    	typedef fizzbuzz< is_divisible::by3::value, is_divisible::by5::value > solution_type; 
    	// stores string or 'false'
    	
    	typedef fizzbuzz_traits<int, N> non_divisible_type; 
    	// stores number
      
    	typedef typename conditional< !is_same<void, typename solution_type::type>::value,
    		solution_type, 
    		non_divisible_type>::type print_type;
    	// stores value to print
    };
    
    
    // Looping from N to M
    template <int N, int M>
    struct static_for{
    	static void value(){
    	std::cout << FizzBuzz<N>::print_type::value << std::endl;
    	static_for<N + 1, M>::value();
    	}
    };
    
    template <>
    struct static_for<101, 100>
    {
    	static void value(){};
    };
    
    int main(){
    	static_for<1, 100>::value();
    }

    Физзбазз на шаблонах без type_traits

    valo94, 17 Июля 2022

    Комментарии (39)
  7. C++ / Говнокод #28250

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    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
    // Calc.cpp : Этот файл содержит функцию "main". Здесь начинается и заканчивается выполнение программы.
    //
    
    #include <iostream>
    using namespace std;
    int main()
    {
    	int one;
    	int two;
    	int plus;
    	int minus;
    	int nas;
    	int del;
    	int zbdel;
    
    		
       cout << "Zadejte prvni cislo: \n";
       cin >> one;
       cout << "\n";
       cout << "Zadejte druhe cislo: \n";
    	   cin >> two;
    	   plus = one + two;
    	   minus = one - two;
    	   nas = one * two;
    	   del = one / two;
    	   zbdel = one % two;
    	   cout << "Scitani: " << plus << "\n";
    	   cout << "Odcitani: " << minus << "\n";
    	   cout << "Nasobeni: " << nas << "\n";
    	   cout << "Deleni: " << del << "\n";
    	   cout << "Zbytek deleni: " << zbdel << "\n";
    }

    kcalbCube, 27 Июня 2022

    Комментарии (7)
  8. C++ / Говнокод #28234

    0

    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    6. 6
    #include <stdio.h>
    
    int main(int argc, char* argv[]) {
    	scanf_s("%s", (char*)argv);
    	return 1;
    }

    Нашел у себя в какой-то папке Memecode Junks 2014 года, не помню зачем это там. Но выглядит весело =))

    DartPower, 24 Июня 2022

    Комментарии (0)
  9. C++ / Говнокод #28228

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    typedef struct {
    
        std::shared_ptr<char*>my_arr;
    
    }MyInputs;
    
    ...
    
    std::shared_ptr<MyInputs> MainDoc (static_cast<MyInputs*>(malloc(sizeof (*MainDoc))),free); 
    
    std::shared_ptr<char*> Z (static_cast<char**>(malloc(sizeof (**MainDoc->my_arr) * 10)),free); 
    std::shared_ptr<char> Z[0](static_cast<char*>(malloc(sizeof (char *) * 10)),free); 
    memcpy(Z[0].get(), (char*)"salut\0", 6);
    
    cout << Z[0] << endl;
    
    ...

    https://stackoverflow.com/questions/27201555/c-array-of-shared-ptr

    kcalbCube, 19 Июня 2022

    Комментарии (2)
  10. C++ / Говнокод #28222

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    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
    #include <clcpp/clcpp.h>
    #include <clcpp/FunctionCall.h>
    
    
    // Reflect the entire namespace and implement each class
    clcpp_reflect(TestClassImpl)
    namespace TestClassImpl
    {
    	class A
    	{
    	public:
    		A()
    		{
    			x = 1;
    			y = 2;
    			z = 3;
    		}
    
    		int x, y, z;
    	};
    
    	struct B
    	{
    		B()
    		{
    			a = 1.5f;
    			b = 2.5f;
    			c = 3.5f;
    		}
    
    		float a, b, c;
    	};
    }
    
    clcpp_impl_class(TestClassImpl::A)
    clcpp_impl_class(TestClassImpl::B)
    
    void TestConstructorDestructor(clcpp::Database& db)
    {
    	const clcpp::Class* ca = clcpp::GetType<TestClassImpl::A>()->AsClass();
    	const clcpp::Class* cb = clcpp::GetType<TestClassImpl::B>()->AsClass();
    
    	TestClassImpl::A* a = (TestClassImpl::A*)new char[sizeof(TestClassImpl::A)];
    	TestClassImpl::B* b = (TestClassImpl::B*)new char[sizeof(TestClassImpl::B)];
    
    	CallFunction(ca->constructor, a);
    	CallFunction(cb->constructor, b);
    
    	CallFunction(ca->destructor, a);
    	CallFunction(cb->destructor, b);
    
    	delete [] (char*) a;
    	delete [] (char*) b;
    }

    https://github.com/Celtoys/clReflect/blob/master/src/clReflectTest/TestClassImpl.cpp

    kcalbCube, 14 Июня 2022

    Комментарии (11)