- 1
- 2
- 3
- 4
typedef typename _STD tr1::conditional<
_STD tr1::is_same<key_type, value_type>::value,
const_iterator,
_Tree_iterator<_Mybase> >::type iterator;
Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
+32
typedef typename _STD tr1::conditional<
_STD tr1::is_same<key_type, value_type>::value,
const_iterator,
_Tree_iterator<_Mybase> >::type iterator;
Шаблоны на шаблонах и шаблонами погоняют.
+24
Fixed f = 0.2;
f = std::abs(f);
std::cout << (float)f;
Угадайте, чему будет равно f?
Fixed - тип из той же библиотеки, что и в http://govnokod.ru/11294
+24
do
{
count++;
Xt=X;
if (ii==1)
{
X= dichotomia(a,b, E);
fprintf(bnf, "%lf;\n", Xt);
}
else
{
if (ii==2)
{
X=newton(X, E);
fprintf(bnf, "%lf;\n", Xt);
}
else
{
if (ii==3)
{
X=sekuschich(X, b);
fprintf(bnf, "%lf;\n", Xt);
}
else
{
if (ii==4)
{
ii==1;
ii==2;
ii==3;
}
}
}
}
printf("X=%lf\n", X);
if(Func(X)*Func(a)>0)a=X;
else b=X;
}
while(fabs(X-Xt)>=E);
В общем лаба на численые методы поиска корней.
После того как я предоставил няшный, полностью удовлетворяющий условиям, после проверки меня попросили "сделать как у парней", и вот участок их высера
p.s. форматирование сохранить не удалось, да и там совсем бы ничего понятно бы не было
+16
template<typename T1, typename T2, size_t OFFSET = 8>
struct EnumMult
{
template<T1 t1, T2 t2>
struct Static
{
static const size_t V = (t1 << OFFSET) | t2;
};
static size_t Dynamic(T1 t1, T2 t2)
{
return (t1 << OFFSET) | t2;
}
};
// example
#include <iostream>
enum Suit
{
SPADES,
CLUBS,
DIAMONDS,
HEARTS
};
enum Value
{
SEVEN,
EIGHT,
NINE,
TEN,
JACK,
QUEEN,
KING,
ACE
};
int main()
{
typedef EnumMult<Suit, Value> CardMult;
switch (CardMult::Dynamic(CLUBS, SEVEN))
{
case CardMult::Static<SPADES, ACE>::V:
std::cout << "ACE OF SPADES";
break;
case CardMult::Static<CLUBS, SEVEN>::V:
std::cout << "HOOK";
break;
default:
std::cout << "NOTHING SPECIAL";
}
std::cout << std::endl;
return 0;
}
Понадобилось обработать два enum'а конструкцией switch-case, подумал, что было бы круто сделать квадратный свитч-кейс, но пришла и другая идиотская идея: шаблон для декартова умножения двух енумов. Заранее извините, если паттерн известный.
+26
input >> heap;
while( heap[0] == '0' ) heap.erase( 0, 1 );
heaps.push_back( heap );
input >> heap;
while( heap[0] == '0' ) heap.erase( 0, 1 );
heaps.push_back( heap );
input >> heap;
while( heap[0] == '0' ) heap.erase( 0, 1 );
heaps.push_back( heap );
+21
template <typename T>
void sort( T array[], size_t length ) {
size_t left_index = 0;
size_t right_index = length - 1;
while ( left_index < right_index ) {
size_t min_index = min( array, left_index, right_index );
swap( array, min_index, left_index );
size_t max_index = max( array, left_index, right_index );
swap( array, max_index, right_index );
left_index++;
right_index--;
}
}
+15
system("PAUSE")
Красивое, оптимальное, и самое главное, кроссплатформенное решение для ожидания нажатия клавиши.
http://habrahabr.ru/post/147104/
Предупреждая вопрос "где здесь с++", отвечу - автор считал, что он пишет на с++, и даже использовал пару конструкций оттуда - перегрузку функций и new/delete.
+15
#pragma once
#include <assert.h>
template<typename T>
inline T notNull(T arg)
{
assert(arg!=NULL);
return arg;
}
/*
//example:
class AnotherClass;
class SomeClass
{
AnotherClass * m_another;
//...
SomeClass(AnotherClass * another, /*skipped*/) : m_another(notNull(another)), /*skipped*/;
}
*/
Мелочь, конечно же, но всё-таки чушь, несмотря на пользу.
+19
// хелпер чтобы конвертить типы строк
template <class S1, class S2>
struct str_convert {
static S1 conv(S2 const & s2) { return str_convert<S2, S1>::conv(s2); } // по умолчанию ищет специализацию для пары S2, S1
static S2 conv(S1 const & s1) { return str_convert<S2, S1>::conv(s1); }
};
// специализация, чтобы не конвертить одно в одно
template <class S>
struct str_convert<S, S> {
static S const & conv(S const & s) { return s; };
};
// специализация, чтобы конвертить std::string <-> std::wstring
template <>
struct str_convert<std::string, std::wstring> {
static std::string conv(std::wstring const & ws) { return boost::locale::conv::utf_to_utf<char>(ws); }
static std::wstring conv(std::string const & s) { return boost::locale::conv::utf_to_utf<wchar_t>(s); }
};
// специализация QString <-> std::string
// skipped
template <class StringType = std::string>
struct some
{
typedef StringType string_type;
typedef std::string utf8_string_type;
some(string_type const & s = string_type())
: inner_string_(s)
{}
template <class S>
some(S const & s)
: inner_string_(str_convert<S, string_type>::conv(s))
{}
string_type inner_string_;
};
int main()
{
std::string s = "hello!";
some<> test0(s); // ok
some<> test2("hello!"); // ха-ха, вот еще, пытаться самостоятельно привести к std::string, пиши специализацию для массивов, сука!
return 0;
}
сегодня ради красоты передачи "literal" в конструктор писал говноспециализации для PodType[N]
+23
if(this==NULL)
return;