- 1
- 2
- 3
- 4
- 5
typedef ::boost::array<T, item_amount+1> not_raw_array;
union data
{
not_raw_array m_raw_array;//Most members of boost::array not suitable for call with raw array. Be careful!
};
Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
Всего: 223
+11
typedef ::boost::array<T, item_amount+1> not_raw_array;
union data
{
not_raw_array m_raw_array;//Most members of boost::array not suitable for call with raw array. Be careful!
};
+15
String testName;
//...
std::swap(testName, _testName);
String из thirdparty-библиотеки, а swap везде в нашем коде. По очевидным причинам получаем подение производительности.
+28
class atoi_func
{
public:
atoi_func(): value_() {}
inline int value() const { return value_; }
inline bool operator() (const char *str, size_t len)
{
value_ = 0;
int sign = 1;
if (str[0] == '-') { // handle negative
sign = -1;
++str;
--len;
}
switch (len) { // handle up to 10 digits, assume we're 32-bit
case 10: value_ += (str[len-10] - '0') * 1000000000;
case 9: value_ += (str[len- 9] - '0') * 100000000;
case 8: value_ += (str[len- 8] - '0') * 10000000;
case 7: value_ += (str[len- 7] - '0') * 1000000;
case 6: value_ += (str[len- 6] - '0') * 100000;
case 5: value_ += (str[len- 5] - '0') * 10000;
case 4: value_ += (str[len- 4] - '0') * 1000;
case 3: value_ += (str[len- 3] - '0') * 100;
case 2: value_ += (str[len- 2] - '0') * 10;
case 1: value_ += (str[len- 1] - '0');
value_ *= sign;
return value_ > 0;
default:
return false;
}
}
private:
int value_;
};
standard atoi()
79142 milliseconds
class atoi_func
131 milliseconds.
Если приходится велосипедить стандартные функции, то это камень в огород С++. Видать кресты писали гении ассемблерной оптимизации.
+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;
}
>После этого всё что нужно освоить про потоки - работу с локами. Локи - это скандинавский бог приостановки потока.
+7
class Pa || Ra || Ll || El
{
int f || o || o; // четвертое ядро простаивает - надо длиннее переменные заводить
int b || a || r;
}
int m || a || i || n(int argc, CHAR* argv[])
{
Parallel parallel = new Pa() || Ra() || Ll() || El ();
}
+125
//сервер сайд (из colors.php)
$colors = [
'banana' => 'yellow',
'orange' => 'orange',
'cucumber' => 'green'
];
echo $colors[$_GET['fruit']];
//клиент сайд (js)
var fruits = ['banana', 'orange', 'cucumber']
for (var i in fruits) {
var fruit = fruits[i]
$.get('colors.php?fruit='+fruit, function(color){
document.write(fruit +' is '+ color +'<br/>')
})
}
Этот код показывают и задают вопрос почти на любом собеседовании на должность web-программита:
Что здесь неверно и как это исправить?
+8
#define I_HATE_MACRO2(BEGIN__, END__) BEGIN__##END__
#define CONCAT_MACRO(BEGIN__, END__) I_HATE_MACRO2(BEGIN__,END__)
+17
class Test
{
public:
Test() : f(&Test::f0), f0(&Test::f1), f1( &Test::f2 ) {}
float ( Test::* const Test::* const Test::* const f)();
private:
float ( Test::* const Test::* const f0)();
float ( Test::* const f1)() ;
float f2() { return 0; }
};
Test t;
cout << (t.*(t.*(t.*(t.f))))();
+141
http://rosettacode.org/wiki/Category:Programming_Tasks
Сегодня это реально сразу куча.
+7
#include <iostream>
namespace detail
{
class CRWO;
class CRO;
class CWO;
class CO;
}
typedef detail::CRWO& CRWO;
typedef detail::CRO& CRO;
typedef detail::CWO& CWO;
typedef detail::CO& CO;
class C
{
friend class detail::CRWO;
friend class detail::CRO;
friend class detail::CWO;
friend class detail::CO;
public:
C( int a ) : value(a) {}
~C() {};
operator CRWO() { return *static_cast<detail::CRWO*>(static_cast<void*>(this)); }
operator CRO() { return *static_cast<detail::CRO*>(static_cast<void*>(this)); }
operator CWO() { return *static_cast<detail::CWO*>(static_cast<void*>(this)); }
operator CO() { return *static_cast<detail::CO*>(static_cast<void*>(this)); }
private:
void set( int newValue ) { value = newValue; }
int get() { return value; }
private:
int value;
};
class detail::CRWO
{
public:
void set( int newValue ) { static_cast<C*>(static_cast<void*>(this))->set( newValue ); }
int get() { return static_cast<C*>(static_cast<void*>(this))->get( ); }
operator ::CRO() { return *static_cast<detail::CRO*>(static_cast<void*>(this)); }
operator ::CWO() { return *static_cast<detail::CWO*>(static_cast<void*>(this)); }
operator ::CO() { return *static_cast<detail::CO*>(static_cast<void*>(this)); }
private:
CRWO(); CRWO(const CRWO&);~CRWO();CRWO& operator=(const CRWO&);void operator&(); void operator*();
};
class detail::CWO
{
public:
void set( int newValue ) { static_cast<C*>(static_cast<void*>(this))->set( newValue ); }
operator ::CO() { return *static_cast<detail::CO*>(static_cast<void*>(this)); }
private:
CWO(); CWO(const CWO&);~CWO();CWO& operator=(const CWO&);void operator&(); void operator*();
};
class detail::CRO
{
public:
int get() { return static_cast<C*>(static_cast<void*>(this))->get( ); }
operator ::CO() { return *static_cast<detail::CO*>(static_cast<void*>(this)); }
private:
CRO(); CRO(const CRO&);~CRO();CRO& operator=(const CRO&);void operator&(); void operator*();
};
class detail::CO
{
public:
private:
CO(); CO(const CO&);~CO();CO& operator=(const CO&);void operator&(); void operator*();
};int main(int argc, char *argv[])
{
C c(3);
CRWO rwo = c;
CRO ro = c;
CWO wo = c;
CO o = c;
std::cout << rwo.get() << std::endl;
wo.set( 5);
std::cout << ro.get() << std::endl;
return 0;
}
Оттуда.
Автор требует указывать авторство при копировании.