Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
+18
#include <iostream>
#define PRINT(val) std::cout << #val \
<< " value: " << val \
<< " address: " << &val << std::endl;
int& constRef(){
int var = 10;
PRINT(var)
return var;
}
int main() {
const int a = 'a', b = 'bcde';
std::cout << a << " " << b << std::endl;
const int& ref = constRef();
PRINT(ref)
}
Малоизвестный синтаксис плюсов.
1. Инициализация целочисленного значения из строки (используется в строках-классах времени компиляции).
2. Константная ссылка на стековый объект (используется для создания DSL, в т.ч. boost::spirit).
P.S.: Более полный вариант со строками лежит на форуме.
crastinus,
28 Декабря 2013
+18
class figure
{
//...
};
class triugolnik: public figure
{
//...
};
class kvadrat: public figure
{
//...
};
#define PAIR(f0, f1) std::make_tuple(std::type_index(typeid(f0)), std::type_index(typeid(f1)))
int PloshadTrehFigur(const figure& f0, const figure& f1, const figure& f2);//forward declaration
int PloshadDvuhFigur(const figure& f0, const figure& f1)
{
static const std::unordered_map<
std::tuple<std::type_index, std::type_index>, std::function<int(const figure&, const figure&)>
> caller
{
{PAIR(triugolnik, kvadrat), ploshadTriugolnikIKvadrat},
{PAIR(kvadrat, triugolnik), lispGovno::flip(ploshadTriugolnikIKvadrat)},
{PAIR(kvadrat, kvadrat), ploshadKvadratIKvadrat},
{PAIR(triugolnik, triugolnik), ploshadTriugolnikITriugolnik}
};
const auto& f = caller.find(PAIR(f0, f1));
assert(f!=caller.end());
f(f0, f1);
}
#undef PAIR
Наш ответ Чемберлену:
http://govnokod.ru/13933
lispGovno::flip - flip такой же как в хаскель из моей особой мегабиблиотеки победителя каждый день.
Шах и мат господа присяжные засидатели. Мультиметоды в крестах есть и реализуются за 5 минут.
В сишке аналогично. Все анскилябры залезли под кровати.
Визитары размазанные по коду сосут и трудно поддерживаются.
LispGovno,
20 Ноября 2013
+18
std::string MetaInfo::SetField() {
return m_value;
}
/* ... */
std::string value = meta.SetValue();Йода-стайл. Переменную эту, хочешь установить ты.
JeremyW,
08 Ноября 2013
+18
std::tuple<std::vector<long double> , std::vector<std::vector<long double> > , std::vector<long double> >
inline
training(const std::size_t hidden_neurons,
const long double hlr,
const std::size_t epochs,
const std::vector< long double > train_ou,
const std::vector< std::vector< long double > >& train_in,
volatile bool * reset)
{
auto train_inp = train_in;
auto train_out = train_ou;
// std::cerr << "hidden_neurons: " << hidden_neurons << std::endl;
// std::cerr << "hlr: " << hlr << std::endl;
// std::cerr << "epochs: " << epochs << std::endl;
// std::cerr << "train_inp: " << train_inp << std::endl;
// std::cerr << "train_out: " << train_out << std::endl;
const auto mu_inp = mean( train_inp );
const auto sigma_inp = stand( train_inp );
train_inp = ( train_inp - mu_inp[ 0 ] ) / sigma_inp[ 0 ];
const auto mu_out = mean( train_out );
const auto sigma_out = stand( train_out );
train_out = ( train_out - mu_out ) / sigma_out;
const auto patterns = size( train_inp ).first;
std::cout << "patterns: " << patterns << std::endl;
auto bias = ones( patterns );
train_inp = merge( train_inp, bias );
const auto inputs = size( train_inp ).second;
std::vector< long double > err( epochs );
auto weight_input_hidden = ( randn( inputs, hidden_neurons) - 0.5l ) / 10.0l;
auto weight_hidden_output = ( randn( hidden_neurons ) - 0.5l ) / 10.0l;
for( std::size_t i = 0; i < epochs; ++i ) {
if ( *reset ) {
break;
}
const auto alr = hlr;
const auto blr = alr / 10.0;
for( std::size_t j = 0; j < patterns; ++j ){
const auto patnum = ( static_cast<std::size_t>( round( randd() * patterns + 0.5 ) ) - 1 ) % patterns;
const auto this_pat = train_inp[ patnum ];
const auto act = train_out[ patnum ];
const auto hval = feval( []( const long double & v ){ return std::tanh( v ); }, this_pat * weight_input_hidden );
const auto pred = hval * weight_hidden_output;
const auto error = pred - act;
const auto delta_HO = hval * error * blr;
weight_hidden_output = weight_hidden_output - delta_HO;
const auto m1 = weight_hidden_output * alr * error;
const auto m2 = 1.0l - (hval^2);
const auto m3 = dot_operator( m1, m2, std::multiplies< long double >());
const auto m4 = vec_to_vecvec( m3 );
const auto delta_IH = m4 * this_pat;
weight_input_hidden = weight_input_hidden - trans( delta_IH );
}
const auto p1 = feval( []( const long double& v ){ return std::tanh( v ); }, train_inp * weight_input_hidden );
const auto pred = weight_hidden_output * trans( p1 );
const auto error = pred - train_out;
const auto error_sq = error ^ 2;
err[ i ] = std::sqrt( std::accumulate( error_sq.cbegin(), error_sq.cend(), 0.0, std::plus<long double> () ) );
std::cerr << "err[ i ]: " << err[ i ] << ' ' << i << std::endl;
}
return std::move(std::make_tuple(weight_hidden_output, weight_input_hidden, err));
}Велосипедостроение
Abbath,
19 Июня 2013
+18
#include "math.h"
#include <iostream>
void Resolve(
float a, float b, float c, // коэффициенты уравнения
int& count, float x[2] // число корней, сами корни
// если корней нет, то значения x[0] и x[1] не определены
// если корень один, то значение x[1] не определено
// если корней бесконечно много, то вернуть INT_MAX
// предполагается, что a,b,c и корни по модулю не превосходят 1E10
)
{
const float MAXFREV = 1e-10f;
if (a==0.0 && b==0.0 && c==0.0)
{
count = INT_MAX;
} else
{
count = 0;
float d = b*b-4.0f*a*c;
if (d==0.0f)
{
if (2.0f*abs(a)>abs(b)*MAXFREV)
x[count++] = -b/(2.0f*a);
} else if (d>0.0f)
{
float num = -b - sqrt(d);
if (2.0f*abs(a)>abs(num)*MAXFREV)
x[count++] = num/(2.0f*a); // (-b-sqrt(d))/2a
if (abs(num)>2.0f*abs(c)*MAXFREV)
x[count++]=(2.0f*c)/num;
}
}
}
int main ()
{
float x[2];
int count;
Resolve (0.0001f,2.000f,0.001f, count, x);
std::cout << "count= " << count;
if (count<=2)
for (int i=0; i<count; ++i)
std::cout << ", x[" << i << "]= " << x[i];
std::cout<<std::endl;
return 0;
}
Просто решение квадратного уравнения.
На флоатах.
Числа подобраны так, что классическая формула лажает, выдавая второй корень -0.000596 вместо -0.0005
TarasB,
18 Июня 2013
+18
word mofs[]={0,
31,
31+28,
31+28+31,
31+28+31+30,
31+28+31+30+31,
31+28+31+30+31+30,
31+28+31+30+31+30+31,
31+28+31+30+31+30+31+31,
31+28+31+30+31+30+31+31+30,
31+28+31+30+31+30+31+31+30+31,
31+28+31+30+31+30+31+31+30+31+30
// ,31+28+31+30+31+30+31+31+30+31+30+31
};"Класс для работы с датами" взятый отсюда: http://yun.complife.ru/soft.htm
bormand,
07 Июня 2013
+18
class Mutex
{
HANDLE m_Mutex;
public:
Mutex()
{
m_Mutex = CreateMutex(0, false, 0);
}
~Mutex()
{
ReleaseMutex(m_Mutex);
CloseHandle(m_Mutex);
}
void Lock()
{
auto lv_WaitResult = WaitForSingleObject(m_Mutex, 10000);
assert(lv_WaitResult != WAIT_TIMEOUT);
}
void Unlock()
{
ReleaseMutex(m_Mutex);
}
};
template<int C>
struct GLocker
{
static Mutex m_Mutex;
};
template<int C> Mutex GLocker<C>::m_Mutex;
class Locker
{
Mutex *m_Mutex;
public:
Locker(Mutex &_Mutex)
{
m_Mutex = &_Mutex;
m_Mutex->Lock();
}
virtual ~Locker()
{
m_Mutex->Unlock();
}
};
class ThreadCreator
{
protected:
static void NewThread(void *_Func)
{
(*(std::function<void()>*)_Func)();
delete (std::function<void()>*)_Func;
}
public:
static ThreadCreator g_ThreadCreator;
HANDLE operator=(const std::function<void()> &_Func)
{
std::function<void()> *lv_Func = new std::function<void()>(_Func);
return (HANDLE)_beginthread(ThreadCreator::NewThread,0,(void*)lv_Func);
}
};
ThreadCreator ThreadCreator::g_ThreadCreator;
#define LOCK const Locker _Lock##__LINE__##__COUNTER__ = GLocker<9000 + __COUNTER__>::m_Mutex // 9000 является запасом для пользовательских номеров.
#define LOCK_EX(Port) const Locker _Lock##__LINE__##__COUNTER__ = GLocker<Port>::m_Mutex // блокирует определённый мьютекс, полезно когда нужно делать синхронизацию из разных мест.
#define GO_FUNC ThreadCreator::g_ThreadCreator =
#define GO_EX(...) GO_FUNC [__VA_ARGS__]() mutable -> void
#define GO GO_FUNC []() -> void
Подсказка сайта:
http://www.gamedev.ru/code/tip/tread_creation
LispGovno,
25 Апреля 2013
+18
//main.cpp:
#define THREAD_COUNT 2
#include "winparallel.h"
main1()
{
lock(1);
int i=0; while(i++<10)
printf("1: %d\n", i);
unlock(1);
}
main2()
{
lock(1);
int i=0; while(i++<10)
printf("2: %d\n", i);
unlock(1);
}
main3(){};
main4(){};
main5(){};
main6(){};
main7(){};
main8(){};
//=====================================================================================
//winparallels.h:
#include <windows.h>
#define _MAX_CORES 8
LPVOID _void;
#define main1() DWORD WINAPI _main1(LPVOID lpParam)
#define main2() DWORD WINAPI _main2(LPVOID lpParam)
#define main3() DWORD WINAPI _main3(LPVOID lpParam)
#define main4() DWORD WINAPI _main4(LPVOID lpParam)
#define main5() DWORD WINAPI _main5(LPVOID lpParam)
#define main6() DWORD WINAPI _main6(LPVOID lpParam)
#define main7() DWORD WINAPI _main7(LPVOID lpParam)
#define main8() DWORD WINAPI _main8(LPVOID lpParam)
DWORD WINAPI _main1(LPVOID);
DWORD WINAPI _main2(LPVOID);
DWORD WINAPI _main3(LPVOID);
DWORD WINAPI _main4(LPVOID);
DWORD WINAPI _main5(LPVOID);
DWORD WINAPI _main6(LPVOID);
DWORD WINAPI _main7(LPVOID);
DWORD WINAPI _main8(LPVOID);
HANDLE _locks[_MAX_CORES];
int _argc; char **_argv;
void lock(int n) { DWORD res = WaitForSingleObject(_locks[n], INFINITE); }
void unlock(int n) { ReleaseMutex(_locks[n]); }
int main(int argc,char **argv) {
HANDLE threads[_MAX_CORES];
DWORD id;
int THREADS = THREAD_COUNT;
if (THREADS<=0) {
SYSTEM_INFO sysinfo;
GetSystemInfo(&sysinfo);
THREADS = sysinfo.dwNumberOfProcessors;
if (THREADS>_MAX_CORES) THREADS = _MAX_CORES;
}
_argc = argc; _argv = argv;
_locks[0] = CreateMutex(NULL,FALSE,NULL);
_locks[1] = CreateMutex(NULL,FALSE,NULL);
_locks[2] = CreateMutex(NULL,FALSE,NULL);
_locks[3] = CreateMutex(NULL,FALSE,NULL);
_locks[4] = CreateMutex(NULL,FALSE,NULL);
_locks[5] = CreateMutex(NULL,FALSE,NULL);
_locks[6] = CreateMutex(NULL,FALSE,NULL);
_locks[7] = CreateMutex(NULL,FALSE,NULL);
threads[0]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)_main1,NULL,0,&id);
if (THREADS>=2)
threads[1]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)_main2,NULL,0,&id);
if (THREADS>=3)
threads[2]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)_main3,NULL,0,&id);
if (THREADS>=4)
threads[3]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)_main4,NULL,0,&id);
if (THREADS>=5)
threads[4]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)_main5,NULL,0,&id);
if (THREADS>=6)
threads[5]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)_main6,NULL,0,&id);
if (THREADS>=7)
threads[6]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)_main7,NULL,0,&id);
if (THREADS>=8)
threads[7]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)_main8,NULL,0,&id);
WaitForMultipleObjects(THREADS, threads, TRUE, INFINITE);
return 0;
}>После этого всё что нужно освоить про потоки - работу с локами. Локи - это скандинавский бог приостановки потока.
LispGovno,
05 Марта 2013
+18
#include <iostream>
#include <map>
struct A {
const static int i = 10;
};
using namespace std;
int main()
{
map<int, string> m;
m[0] = "zero";
m[A::i] = "A::i"; // Не везде работает
cout << A::i << endl;
return 0;
}
Недели stackoverflow на уютненьньком.
Почему-то этот код не собирается в GCC 4.7.2, но при этом работает в 4.6.3 и 4.8.0.
http://liveworkspace.org/code/2o5qOP$1
http://liveworkspace.org/code/2o5qOP$2
http://liveworkspace.org/code/2o5qOP$3
absolut,
01 Марта 2013
+18
template <typename Derived>
class Base {
public:
void doSmth() {
// ...
static_cast<Derived*>(this)->OnParseAndHandle();
//...
}
};
class MyClass: public Base<MyClass> {
public:
void OnParseAndHandle() {
// ...
}
};
Если Вы не верите в виртуальные методы, то шаблоны Вам в помощь.
А может я идиот и чего-то не понял?
benderlog,
26 Января 2013
Follow us!