По колено в коде — Говнокод.ру

Куча / Говнокод #-27319

+1

1

Просто оффтоп #17

#1: https://govnokod.ru/20162 https://govnokod.xyz/_20162
#2: https://govnokod.ru/25329 https://govnokod.xyz/_25329
#3: https://govnokod.ru/25415 https://govnokod.xyz/_25415
#4: (vanished) https://govnokod.xyz/_25472
#5: https://govnokod.ru/25693 https://govnokod.xyz/_25693
#6: (vanished) https://govnokod.xyz/_26649
#7: https://govnokod.ru/26672 https://govnokod.xyz/_26672
#8: https://govnokod.ru/26924 https://govnokod.xyz/_26924
#9: https://govnokod.ru/27072 https://govnokod.xyz/_27072
#10: https://govnokod.ru/27086 https://govnokod.xyz/_27086
#11: https://govnokod.ru/27122 https://govnokod.xyz/_27122
#12: https://govnokod.ru/27153 https://govnokod.xyz/_27153
#13: https://govnokod.ru/27159 https://govnokod.xyz/_27159
#14: https://govnokod.ru/27200 https://govnokod.xyz/_27200
#15: https://govnokod.ru/27237 https://govnokod.xyz/_27237
#16: https://govnokod.ru/27282 https://govnokod.xyz/_27282

nepeKamHblu_nemyx, 26 Марта 2021

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

C# / Говнокод #27318

+2

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

using System.Device.Gpio;
using System;
using System.Threading;

namespace Blinky
{
	public class Program
    {
        private static GpioController s_GpioController;
        public static void Main()
        {
            s_GpioController = new GpioController();

            // ESP32 DevKit: 4 is a valid GPIO pin in, some boards like Xiuxin ESP32 may require GPIO Pin 2 instead.
            GpioPin led = s_GpioController.OpenPin(4,PinMode.Output);
            led.Write(PinValue.Low);

            while (true)
            {
                led.Toggle();
                Thread.Sleep(125);
                led.Toggle();
                Thread.Sleep(125);
                led.Toggle();
                Thread.Sleep(125);
                led.Toggle();
                Thread.Sleep(525);
            }
        }        
    }
}

https://habr.com/ru/post/549012/: «.NET nanoFramework — платформа для разработки приложений на C# для микроконтроллеров».

Ну все, последний оплот сишки пал, можно ее закапывать.

PolinaAksenova, 25 Марта 2021

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

C++ / Говнокод #27317

+1

1

pubimbue, ate и ios

давайте ржать над крестостримами

booratihno, 25 Марта 2021

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

C++ / Говнокод #27316

+2

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

#include <array>
#include <iostream>
#include <string_view>
#include <type_traits>

std::string_view getMaxMargin();

template<int bit_num>
struct flag {
    friend constexpr int adl_flag(flag<bit_num>);
};

template<int bit_num>
struct writer {
    friend constexpr int adl_flag(flag<bit_num>)
    {
        return bit_num;
    }

    static constexpr int value = bit_num;
};

template<int bit_num, int = adl_flag(flag<bit_num>{})>
constexpr bool is_flag_set(int, flag<bit_num>)
{
    return bit_num >= 0;
}

template<int bit_num>
constexpr bool is_flag_set(float, flag<bit_num>)
{
    return false;
}

template<size_t number, size_t bit_num>
constexpr bool get_bit()
{
    return (number & (1 << bit_num)) != 0;
}

#define flags_to_size()                     \
     ((is_flag_set<0>(0, flag<0>{}) << 0)   \
    | (is_flag_set<1>(0, flag<1>{}) << 1)   \
    | (is_flag_set<2>(0, flag<2>{}) << 2)   \
    | (is_flag_set<3>(0, flag<3>{}) << 3))

template<bool test, typename T_true, typename T_false>
struct meta_if {
    using type = T_true;
};

template<typename T_true, typename T_false>
struct meta_if<false, T_true, T_false> {
    using type = T_false;
};

template<bool test, typename T_true, typename T_false>
using meta_if_t = typename meta_if<test, T_true, T_false>::type;

template<
    size_t desired_size,
    int = (0 +
           sizeof(meta_if_t<get_bit<desired_size, 0>(), writer<0>, int>) +
           sizeof(meta_if_t<get_bit<desired_size, 1>(), writer<1>, int>) +
           sizeof(meta_if_t<get_bit<desired_size, 2>(), writer<2>, int>) +
           sizeof(meta_if_t<get_bit<desired_size, 3>(), writer<3>, int>)
    )
>
constexpr size_t f()
{
    return desired_size;
}

int main()
{
    constexpr size_t a = f<1>();
    constexpr size_t b = f<6>();
    std::cout << "Max margin size: " << getMaxMargin().size() << std::endl;
}

constexpr size_t MARGIN_SIZE = flags_to_size();
constexpr char MARGIN_CHAR = 'x';

template<typename T, T... Args>
constexpr auto getMarginStorageImpl(std::integer_sequence<T, Args...>)
{
    return std::array<char, sizeof...(Args)>{(static_cast<void>(Args), MARGIN_CHAR)...};
}
constexpr auto getMarginStorage()
{
    return getMarginStorageImpl(std::make_integer_sequence<int, MARGIN_SIZE>());
}
constexpr static auto marginStorage = getMarginStorage();;

std::string_view getMaxMargin()
{
    return std::string_view(marginStorage.data(), MARGIN_SIZE);
}

"Интересно, можно ли насфиначить такой шаблон, чтобы в пределах TU сгенерированные литералы были слайсами одного статического массива, длина которого выводилась бы автоматически."

PolinaAksenova, 25 Марта 2021

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

Куча / Говнокод #27315

+1

01
02
03
04
05
06
07
08
09
10
11
12
13
14

?check_trace(
       begin
           %% Inject some orderings to make sure the replicant
           %% receives transactions in all states.
           %%
           %% 1. Commit some transactions before the replicant start:
           ?force_ordering(#{?snk_kind := trans_gen_counter_update, value := 5}, #{?snk_kind := state_change, to := disconnected}),
           %% 2. Make sure the rest of transactions are produced after the agent starts:
           ?force_ordering(#{?snk_kind := subscribe_realtime_stream}, #{?snk_kind := trans_gen_counter_update, value := 10}),
           %% 3. Make sure transactions are sent during TLOG replay:
           ?force_ordering(#{?snk_kind := state_change, to := bootstrap}, #{?snk_kind := trans_gen_counter_update, value := 15}),
           %% 4. Make sure some transactions are produced while in normal mode
           ?force_ordering(#{?snk_kind := state_change, to := normal}, #{?snk_kind := trans_gen_counter_update, value := 25}),
...

Какой тест )))

CHayT, 24 Марта 2021

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

Куча / Говнокод #27314

+1

1
2
3
4
5
6
7
8

# PowerShell

switch ($true)
{
    ($firstNumber -gt $secondNumber) {Write-Output ("{0} > {1}" -F $firstNumber, $secondNumber)}
    ($firstNumber -eq $secondNumber) {Write-Output ("{0} == {1}" -F $firstNumber, $secondNumber)}
    ($firstNumber -lt $secondNumber) {Write-Output ("{0} < {1}" -F $firstNumber, $secondNumber)}
}

Интересный такой свитч-кейс (https://stackoverflow.com/questions/57063932/powershell-overriding-assignment-and-comparison-operators)

groser, 24 Марта 2021

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

Java / Говнокод #27313

+5

1
2
3

private static String getMargin(final int size) {
        return "                                                                                                                             ".substring(0, 6 * size);
    }

Как создать пустую строку с заданной длиной...

nekkiy, 24 Марта 2021

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

C++ / Говнокод #27312

+1

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#include <iostream>

template<typename T>
struct CrtpBase {
    static float base_func()
    {
        std::cout << "CrtpBase::base_func(), " << typeid(T).name() << "::int_field == "
            << T::int_field << std::endl;
        return 16.0f;
    }

    static inline float x = base_func();
};

struct A: public CrtpBase<A> {
    void func_a()
    {
        base_func();
    }

    static inline int int_field = 16;
};

struct B : public CrtpBase<B> {
    void func_b()
    {
        std::cout << "B::func_b(), no CrtpBase<B>::base_func() call" << std::endl;
    }
};


int main()
{
    A a;
    a.func_a();

    B b;
    b.func_b();
}

[temp.inst]/2:

    Unless a class template specialization is a declared specialization,

    the class template specialization is implicitly instantiated when

    the specialization is referenced in a context that requires a

    completely-defined object type or when the completeness of the

    class type affects the semantics of the program.



[temp.inst]/3:

    The implicit instantiation of a class template specialization causes

    (3.1) -- the implicit instantiation of the declarations, but not of the definitions, of

        the non-deleted class member functions, member classes, scoped member enumerations,

        static data members, member templates, and friends; and

    (3.2) -- the implicit instantiation of the definitions of deleted member functions,

        unscoped member enumerations, and member anonymous unions.



[temp.inst]/4:

    Unless a member of a templated class is a declared specialization, the specialization

    of the member is implicitly instantiated when the specialization is referenced in a

    context that requires the member definition to exist or if the existence of the definition

    of the member affects the semantics of the program; in particular, the initialization

    (and any associated side effects) of a static data member does not occur unless the

    static data member is itself used in a way that requires the definition of the static

    data member to exist.

Таким образом, по стандарту CrtpBase<B>::x не должен быть инициализирован, поскольку он нигде не used in a way that requires the definition of the static data member to exist. Правильные компиляторы (gcc и clang) это понимают и компилируют код, а вот Visual Studio зачем-то пытается инициализировать CrtpBase<B>::x и нон-конформно ломается.

PolinaAksenova, 24 Марта 2021

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

C++ / Говнокод #27311

+3

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

// A registrator class.
// To register a Parents <- Child relation user must derive their type from
// the correct specialization of this class
template<typename Child, typename... Parents>
struct registrator {
private:
    // The registerRelation() function would be called during dynamic initialization of this
    // static storage duration variable.
    static volatile inline detail::registratorType _registrator
        = RelationManager::registerRelation<Child, Parents...>();

protected:
    /*
    [basic.start.dynamic]/6:
        It is implementation-defined whether the dynamic initialization of a non-block inline variable
        with static storage duration is sequenced before the first statement of main or is deferred.
        If it is deferred, it strongly happens before any non-initialization odr-use of that variable.
    [basic.start.dynamic]/4:
        A non-initialization odr-use is an odr-use ([basic.def.odr]) not caused directly or indirectly
        by the initialization of a non-block static or thread storage duration variable.
    By odr-using the _registrator here we are making sure that any Child constructor is odr-using it as well,
    thus guaranteeing that the compiler would call registerRelation() strongly before the Child constructor
    */
    constexpr registrator() noexcept
    {
        // Taking an address of a variable, even in a discarded statement, is an odr-use
        (void)&_registrator;
    }

private:
    /*
    If registrator() constructor is never 'non-initialization odr-used'
    (no Child objects are created besides non-local static ones), then the only
    instantiation of the registrator class is an implicit instantiation caused by deriving Child;

    [temp.inst]/3:
        The implicit instantiation of a class template specialization causes
        (3.1) -- the implicit instantiation of the declarations, but not of the definitions, of
            the non-deleted class member functions, member classes, scoped member enumerations,
            static data members, member templates, and friends; and
        (3.2) -- the implicit instantiation of the definitions of deleted member functions,
            unscoped member enumerations, and member anonymous unions.

    [basic.def.odr]/8:
        [...] A constructor for a class is odr-used as specified in [dcl.init].
    (In other words, "A constructor (including default constructors) for a class
     is odr-used by the initialization that selects it.")

    The problem is that if there is no Child() constructor calls, then the compiler is not required to
    even DEFINE our registrator() constructor, and since there is only one odr-use of the static inline
    variable _registrator, the compiler is not required to generate a definition for it as well. And since
    it is not generating a definition, the initialization is also not generated.

    But [temp.inst]/3.2 requires that any implicit instantiation of a class template also
    causes the DEFINITION instantiation of an unscoped member enumerations. Next,
    [dcl.spec.auto.general]/12:
        Return type deduction for a templated entity that is a function or function template
        with a placeholder in its declared type occurs when the definition is instantiated
        even if the function body contains a return statement with a non-type-dependent operand
    Thus, using sizeof(*_force_registrator_instantiation()) causes the implicit instantiation
    of definition of _force_registrator_instantiation(), and since this function is odr-using _registrator,
    its definition (and initialization) is also generated.

    The only problem is that by [basic.start.dynamic]/6 the implementation MAY defer the dynamic
    initialization of _registrator to the point where it is 'non-initialization odr-used', and since without
    the Child() constructor call we don't have any way to non-initialization odr-use it, we also have no way to
    make sure that the compiler invokes registerRelation() before main() or before any other point of execution.
    The good news, though, is that all three modern compilers obediently initializes _registrator before the first
    statement of main().
    */
    static auto _force_registrator_instantiation()
    {
        return &_registrator;
    }

    enum {
        _ROTARTSIGER_ETAITNATSNI = sizeof(*_force_registrator_instantiation()),
    };
};

PolinaAksenova, 23 Марта 2021

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

JavaScript / Говнокод #27310

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

$(".reg_button").on("click", function(){
    console.log("hello world jquery");
    $(".main").css("display", "none");
    $(".register-main").css("display", "block");
    $(`input[type="text"]`).css("width", "14vw");
    $(`input[type="password"]`).css("width", "14vw");
    $(`input[type="email"]`).css("width", "14vw");
     // Обработка нажатия на кнопку регистрации
});
const recovery = {
  login: "",
  email: "",
}
const regExp = {
  login: /^[a-z0-9_-]{5,20}$/,
  pass: /^[A-Za-z0-9_-]{6,16}$/,
  email: /^[A-Z0-9._%+-]+@[A-Z0-9-]+.+.[A-Z]{2,4}$/i,
}
const state = {
  reg: {
    login: "",
    pass: "",
    email: "",
    agreement: ""
  },
  auth: {
    login: "",
    pass: "",
    agreement: false
  }
  }
$(".back").on("click", function() {
    $(".register-main").css("display", "none");
    $(".main").css("display", "flex");
    $(`input[type="text"]`).css("width", "21.5vw");
    $(`input[type="password"]`).css("width", "21.5vw");
    // Обработка нажатия на кнопку "Назад"
});
$(".auth_forgotPassword").on("click", function() {
  console.log("Система восстановления пароля в разработке.")
 /* $(".main").css("display", "none");
  $(".recovery").css("display", "block");
  $(".recovery-step-one").css("display", "block");
  $(`input[type="text"]`).css("width", "14vw");
  $(`input[type="password"]`).css("width", "14vw"); */
})
$(".recovery-back").on("click", function() {
  $(".recovery").css("display", "none");
  $(".recovery-step-one").css("display", "none");  
  $(".main").css("display", "flex");                 // кнопка назад, в восстановления пароля.
  $(`input[type="text"]`).css("width", "21.5vw");
  $(`input[type="password"]`).css("width", "21.5vw");
})
$(".recovery-back2").on("click", function() {
  $(".recovery-step-two").css("display", "none");
  $(".recovery").css("display", "block");     
  $(".recovery-step-one").css("display", "block");                  // кнопка назад, в восстановления пароля.
  $(`input[type="text"]`).css("width", "14vw");
  $(`input[type="password"]`).css("width", "14vw");
})
// $(".recovery-button").on("click", function() {
  /*recovery.login = $(".step_login").val()
  recovery.email = $(".step_email").val()
  alt.emit("click:recovery")
  if(recovery.login == "" || recovery.email == "" )
  {
    console.log("Необходимые поля пустые!")
  }
  else {
  alt.on("recovery-step-two", (args) => {
  if(args == true) {
    $(".recovery-step-one").css("display", "none");
    $(".recovery-step-two").css("display", "block");
  }
  else {
    console.log("Введены неверные данные или аккаунта с такой почтой не существует.")
  }
  })
  }
  */
// })
$(".recovery_button2").on("click", function() {
  $(".recovery-step-two").css("display", "none");
  $(".recovery-step-three").css("display", "block");
})
$('.button-wrap').on("click", function(){
  $(this).toggleClass('button-active');
  if ($(this).hasClass('button-active')) {
    localStorage.checkbox = 1
    
  } else {
    localStorage.checkbox = 0
  }
  console.log(localStorage.checkbox)
});
$(".confirm-back2").on("click", () => {
  $(".authentication").css("display", "none");

Логика работы меню авторизации :)
Собственно первая моя верстка была, как и использование jquery)

Seagate, 22 Марта 2021