C++ — Говнокод.ру

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

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

// А какие-нибудь IDE с интегрированными отладчиками (или
// отладчики сами по себе) умеют нахрен выкидывать всякую
// там компилтайм-метушню из кода, оставляя лишь то, что
// реально исполняется в рантайме?

// Ну например, чтобы хуйня вида
if constexpr(хуйня1)
{
  bagor1();
  if constexpr(хуйня2)
  {
    bagor11();
  }
  else
  {
    bagor12();
  }
}
else
{
  bagor2();
  if constexpr (хуйня3)
  {
    bagor21();
  }
  bagor();
}

// и если хуйня1 == true и хуйня2 == false то чтоб в отладчике
// в какой-то там говноIDE я увидел бы не эту пидоросню с if consexpr
// а только лишь

bagor1();
bagor12();

Есть ли такое?

j123123, 18 Апреля 2021

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

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

+4

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21

int main()
{
    using Human = NamedTuple<
        Field<"name", std::string>,
        Field<"age", int>
    >;
    using User = NamedTuple<
        Field<"login", std::string>,
        Field<"password", std::string>
    >;

    Human vasya{ "Vasya", 16 };
    vasya.get<"age">() = 17;

    User user{ "xXxBaCRHxXx", "p4ssword" };

    auto vasyaMerged = mergeNamedTuples(vasya, user);

    std::cout << vasyaMerged.get<"name">() << " is " << vasyaMerged.get<"age">() << " years old!" << std::endl;
    std::cout << "Login is " << vasyaMerged.get<"login">() << " and password is " << vasyaMerged.get<"password">() << std::endl;
}

Как похорошел C++ при C++20!

https://wandbox.org/permlink/llpXuy7IOSugtxHo

PolinaAksenova, 18 Апреля 2021

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

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

+3

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

std::cout << "Creating ptr1!" << std::endl;
auto ptr1 = make_nft<Cow>();
std::cout << "ptr1(" << &ptr1 << "): " << ptr1.get() << std::endl;
ptr1->MakeSound();

std::cout << "Creating ptr2!" << std::endl;
nft_ptr<Animal> ptr2;
std::cout << "ptr2(" << &ptr2 << "): " << ptr2.get() << std::endl;
std::cout << "Moving: ptr2 = std::move(ptr1)" << std::endl;
ptr2 = std::move(ptr1);
std::cout << "Moved: ptr1 = " << ptr1.get() << " ptr2 = " << ptr2.get()
          << std::endl;

https://github.com/zhuowei/nft_ptr

"C++ std::unique_ptr that represents each object as an NFT on the Ethereum blockchain."

PolinaAksenova, 13 Апреля 2021

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

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

0

1
2
3
4
5
6
7
8
9

void main()
{
	unsigned char c=0;
	for (int c = 0;c < 256; c++) {
		cout << "the value of '" << c << "' is: " << int(c) << '\n';
		
	}
	
}

Ой, а чойта оно повесилося и пикает?

untitled_001, 12 Апреля 2021

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

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

+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
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

// https://govnokod.ru/27340#comment621647

#include <iostream>
#include <cstdlib>

#define SPLICE(a,b) SPLICE_1(a,b)
#define SPLICE_1(a,b) SPLICE_2(a,b)
#define SPLICE_2(a,b) a##b


#define PP_ARG_N( \
          _1,  _2,  _3,  _4,  _5,  _6,  _7,  _8,  _9, _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, N, ...) N

/* Note 63 is removed */
#define PP_RSEQ_N()                                        \
         62, 61, 60,                                       \
         59, 58, 57, 56, 55, 54, 53, 52, 51, 50,           \
         49, 48, 47, 46, 45, 44, 43, 42, 41, 40,           \
         39, 38, 37, 36, 35, 34, 33, 32, 31, 30,           \
         29, 28, 27, 26, 25, 24, 23, 22, 21, 20,           \
         19, 18, 17, 16, 15, 14, 13, 12, 11, 10,           \
          9,  8,  7,  6,  5,  4,  3,  2,  1,  0

#define PP_NARG_(...)    PP_ARG_N(__VA_ARGS__)    

/* Note dummy first argument _ and ##__VA_ARGS__ instead of __VA_ARGS__ */
// note: using __VA_OPT__ shit instead ##__VA_ARGS__
#define PP_NARG(...)     PP_NARG_(_ __VA_OPT__(,) __VA_ARGS__, PP_RSEQ_N())

#define MK_VAR_T(type, name) \
typeof(type) name

#define TYPE_ADD_0()

#define TYPE_ADD_1(VAR) \
  MK_VAR_T VAR;
#define TYPE_ADD_2(VAR, ...) \
  MK_VAR_T VAR; TYPE_ADD_1(__VA_ARGS__)
#define TYPE_ADD_3(VAR, ...) \
  MK_VAR_T VAR; TYPE_ADD_2(__VA_ARGS__)
#define TYPE_ADD_4(VAR, ...) \
  MK_VAR_T VAR; TYPE_ADD_3(__VA_ARGS__)
#define TYPE_ADD_5(VAR, ...) \
  MK_VAR_T VAR; TYPE_ADD_4(__VA_ARGS__)
#define TYPE_ADD_6(VAR, ...) \
  MK_VAR_T VAR; TYPE_ADD_5(__VA_ARGS__)
#define TYPE_ADD_7(VAR, ...) \
  MK_VAR_T VAR; TYPE_ADD_6(__VA_ARGS__)
#define TYPE_ADD_8(VAR, ...) \
  MK_VAR_T VAR; TYPE_ADD_7(__VA_ARGS__)
#define TYPE_ADD_9(VAR, ...) \
  MK_VAR_T VAR; TYPE_ADD_8(__VA_ARGS__)
#define TYPE_ADD_10(VAR, ...) \
  MK_VAR_T VAR; TYPE_ADD_9(__VA_ARGS__)
#define TYPE_ADD_11(VAR, ...) \
  MK_VAR_T VAR; TYPE_ADD_10(__VA_ARGS__)


#define TYPE_ADD_(N, ...) \
  SPLICE(TYPE_ADD_, N)(__VA_ARGS__)

#define TYPE_ADD(...) \
  TYPE_ADD_(PP_NARG(__VA_ARGS__), __VA_ARGS__)

#define REM_BRACKET(...) __VA_ARGS__

#define LAMBDA(name, vars, code) \
struct name {TYPE_ADD vars void operator()() const REM_BRACKET code}

int main()
{
  LAMBDA
  (
    some_type_name,
    ((int, a), (float, b), (double, c)),
    ({
      std::cout << "Hello, world! " << a << " " << b << " " << c << std::endl;
    })
  );
  
  auto lambda = some_type_name(1, 3.14f, 0.25);
  lambda();
}

Вот вам говнолямбда на препроцессоре.

j123123, 11 Апреля 2021

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

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

+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

void printParser(const wchar_t *fileName, const wchar_t *str, boolean showLineCharPos)
{
    ts::Parser parser;
    auto sourceFile = parser.parseSourceFile(fileName, str, ScriptTarget::Latest);

    ts::FuncT<> visitNode;
    ts::ArrayFuncT<> visitArray;

    auto intent = 0;

    visitNode = [&](ts::Node child) -> ts::Node {

        for (auto i = 0; i < intent; i++)
        {
            std::cout << "\t";
        }

        std::cout << "Node: " << wtoc(parser.syntaxKindString(child).c_str()) << " @ [ " << child->pos << " - " << child->_end << " ]" << std::endl;

        intent++;
        ts::forEachChild(child, visitNode, visitArray);    
        intent--;

        return undefined;
    };

    visitArray = [&](ts::NodeArray<ts::Node> array) -> ts::Node {
        for (auto node : array)
        {
            visitNode(node);
        }

        return undefined;
    };

    auto result = ts::forEachChild(sourceFile.as<ts::Node>(), visitNode, visitArray);
}

спортировал TypeScript парсер в C++ и ахренел от обьема работы :)

ASD_77, 06 Апреля 2021

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

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

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
98
99

class MyString
{
public:
	MyString(const char* str)
	{
		symbol = strlen(str);
		this->str = new char[symbol + 1];
		for (int i = 0; i < symbol; i++)
		{
			this->str[i] = str[i];
		}
		this->str[symbol] = '\0';
	}
	int Size()
	{
		return symbol;
	}
	MyString()
	{
		str = nullptr;
		symbol = 0;
	}
	~MyString()
	{
		delete[] str;
	}
	MyString(const MyString& objct)
	{
		symbol = strlen(objct.str);
		this->str = new char[symbol + 1];
		for (int i = 0; i < symbol; i++)
		{
			this->str[i] = objct.str[i];
		}
		this->str[symbol] = '\0';
	}
	MyString operator ()(const char* objct)
	{
		if (this->str != nullptr)
		{
			delete[] this->str;
		}
		symbol = strlen(objct);
		this->str = new char[symbol + 1];
		for (int i = 0; i < symbol; i++)
		{
			this->str[i] = objct[i];
		}
		this->str[symbol] = '\0';
		return *this;
	}
	MyString& operator =(MyString& objct)
	{
		if (this->str != nullptr)
		{
			delete[] str;
		}
		symbol = strlen(objct.str);
		this->str = new char[symbol + 1];
		for (int i = 0; i < symbol; i++)
		{
			this->str[i] = objct.str[i];
		}
		this->str[symbol] = '\0';
		return *this;
	}
	MyString operator +(MyString& objct)//конкатенация строк
	{
		MyString NEWString;
		symbol = strlen(this->str);
		Ssymbol = strlen(objct.str);
		NEWString.str = new char[symbol + Ssymbol + 1];
		int i = 0;
		NEWString.symbol = symbol + Ssymbol;
		for (; i < symbol; i++)
		{
			NEWString.str[i] = this->str[i];
		}
		for (int j = 0; j < Ssymbol; j++, i++)
		{
			NEWString.str[i] = objct.str[j];
		}
		NEWString.str[symbol + Ssymbol] = '\0';
		return NEWString;
	}
	//перегруженные операторы........
 int main()
{
	MyString asd = "Go";
	MyString aa = "God";
	if (asd >= aa)
	{
		cout << "Первая переменная больше по символам чем вторая." << endl;
	}
	else
	{
		cout << "Первая переменная меньше по символам чем вторая." << endl;
	}
}

Свой класс строк. Что можно поправить для лучшей оптимизации?

1337, 28 Марта 2021

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

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

+1

1

pubimbue, ate и ios

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

booratihno, 25 Марта 2021

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

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)

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)

Говнокод: по колено в коде.