- 1
- 2
- 3
t = Min(::std::cref(x), ::std::cref(y));
//или в зависимости от ситуации
t = Min(::std::move(x), ::std::move(y));
Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
+36
t = Min(::std::cref(x), ::std::cref(y));
//или в зависимости от ситуации
t = Min(::std::move(x), ::std::move(y));
Абстракционизм или Кубизм?
+31
#include <string>
#include <iostream>
#include <functional>
using namespace std;
template<class L, class... Ls>
struct OL: L, OL<Ls...>{
OL(const L& l, const Ls&... ls): L(l), OL<Ls...>(ls...){}
using L::operator();
using OL<Ls...>::operator();
};
template<class L1, class L2>
struct OL<L1, L2>: L1, L2{
OL(const L1& l1, const L2& l2): L1(l1), L2(l2){}
using L1::operator();
using L2::operator();
};
template<class... Ls>
OL<Ls...> OverloadLambda(const Ls&... l){
return OL<Ls...>(l...);
}
template<class L>
L OverloadLambda(const L& l){
return l;
}
void OverloadLambda(void) = delete;
int main() {
int i=5;
auto lambda=OverloadLambda( [=](int v){cout<<__func__<<" "<<i<<" "<<v<<" int"<<endl;},
[=](string v){cout<<__func__<<" "<<i<<" "<<v<<" string"<<endl;},
[=](float v){cout<<__func__<<" "<<i<<" "<<v<<" float"<<endl;});
lambda(0);
lambda("Hello");
lambda(1.0f);
i=600;
auto lambda1=OverloadLambda( [=](int v){cout<<__func__<<" "<<i<<" "<<v<<" int"<<endl;});
lambda1(4);
///*auto lambda0 =*/ OverloadLambda();
return 0;
}
Специальная олимпиада объявляется открытой!
http://ideone.com/y14z5Y
Там много другого кода и какой-то из старых тем, а мне лень весь облазить.
+33
template<typename F, typename... Fns>
struct Overloaded
{
std::tuple<F,Fns...> fns;
// эта и следующая за ней функция нужны для рекурсивного
// накопления кортежа из всех входящих функций
template<typename First, typename... Others>
std::tuple<First,Others...> collect(First f, Others... others) {
auto t = std::make_tuple(f);
return std::tuple_cat(t, collect(others...));
}
template<typename Single>
std::tuple<Single> collect(Single f) {
return std::make_tuple(f);
}
Overloaded(F f, Fns... others) {
// сохраняем кортеж функций
fns = collect(f, others...);
}
};
template<typename F, typename... Fns>
Overloaded<F,Fns...> make_overloaded(F f, Fns... fns) {
return Overloaded<F,Fns...>(f,fns...);
}
//...
void F1(int) {}
void F2(int, float) {}
// ...
auto f = make_overloaded(F1, F2);
Не хочется связываться с бустом ввиду его убогости громоздкости. Поэтому пытаюсь сделать сам на чистом C++11 без макросов.
Не понятно теперь как перегрузить оператор ()?
Задействовать enable_if? Ни чего в голову не приходит.
Есть у кого идеи?
Оттуда
+24
int f(int = 7, int * = nullptr, int (*(*)(double))[3] = nullptr){
http://ideone.com/BcZ7Ja
+15
#define TEST_MODE ON
...
#ifdef TEST_MODE
# include "fake_singelton.h"
#else
# include "work_singelton.h"
#endif
оттуда
+20
Ini ini(m_serviceProvider);
if( ini.load( gameInputStream ) == false )
{
LOGGER_ERROR(m_serviceProvider)("StartupConfigLoader::loadGame_ Invalid load game settings '%s'"
, _gameIniPath.c_str()
);
return false;
}
IniUtil::getIniValue( ini, "Project", "Name", _settings.projectName, m_serviceProvider );
IniUtil::getIniValue( ini, "Project", "Company", _settings.companyName, m_serviceProvider );
IniUtil::getIniValue( ini, "Project", "Codename", _settings.applicationSettings.projectCodename, m_serviceProvider );
IniUtil::getIniValue( ini, "Project", "Version", _settings.applicationSettings.projectVersion, m_serviceProvider );
IniUtil::getIniValue( ini, "Locale", "Default", _settings.defaultLocale, m_serviceProvider );
IniUtil::getIniValue( ini, "Game", "ContentResolution", _settings.applicationSettings.contentResolution, m_serviceProvider );
IniUtil::getIniValue( ini, "Game", "FixedContentResolution", _settings.applicationSettings.fixedContentResolution, m_serviceProvider );
IniUtil::getIniValue( ini, "Game", "PersonalityModule", _settings.personalityModule, m_serviceProvider );
IniUtil::getIniValue( ini, "Game", "AlreadyRunning", _settings.alreadyRunning, m_serviceProvider );
IniUtil::getIniValue( ini, "Game", "WindowModeCheck", _settings.applicationSettings.windowModeCheck, m_serviceProvider );
IniUtil::getIniValue( ini, "Window", "Size", _settings.applicationSettings.windowResolution, m_serviceProvider );
IniUtil::getIniValue( ini, "Window", "Bits", _settings.applicationSettings.bits, m_serviceProvider );
IniUtil::getIniValue( ini, "Window", "Fullscreen", _settings.applicationSettings.fullscreen, m_serviceProvider );
IniUtil::getIniValue( ini, "Window", "MaxFPS", _settings.maxfps, m_serviceProvider );
IniUtil::getIniValue( ini, "Window", "VSync", _settings.applicationSettings.vsync, m_serviceProvider );
Это оттуда уже другой. Они все сговорились что-ли? Ынтерпрайз головного мозга.
PS: boost::property_map не осилил.
+4
struct ServiceProvider1
{
ServiceProvider1(Service2& service1, Service3& service2, Service3& service3, Service4& service4, Service5& service5):
service1(service1),
service2(service2),
service3(service3),
service4(service4),
service5(service5),
{}
fun<Service1> service1;//fun - функциональный объект (operator() перегружен), хранящий ссылку на сервис, чтобы не писать кроме членов ещё и две функции - константную и не константную.
fun<Service2> service2;
fun<Service3> service3;
fun<Service4> service4;
fun<Service5> service5;
};
class Service1
{
public:
template<class ServiceProvider>
Service1(ServiceProvider serviceProvider):
service2(serviceProvider.service2()),//Ссылки на сервисы получаем.
service3(serviceProvider.service3()),
myMember1(serviceProvider),//эти мемберы сами внутри воспользуются провайдерами зависимостей
myMember2(serviceProvider),
myMember3(),
myMember4(myServiceProviderGeter<ServiceProvider>()),//Этому мембору понадобились новые зависимости, часть тех, что хранятся в ServiceProvider, а часть новых среди членов Service1.
myMember5(myServiceProviderGeter<ServiceProvider>())
myMember6(myServiceProviderGeter<ServiceProvider>())
{}
...
private:
template<class BaseServiceProvider>
struct MyServiceProvider: BaseServiceProvider
{
MyServiceProvider(BaseServiceProvider baseServiceProvider, Service6& service6, Service7& service7):
BaseServiceProvider(baseServiceProvider),
service6(service6),
service7(service7)
{}
fun<Service6> service6;
fun<Service7> service7;
};
template<class BaseServiceProvider> MyServiceProvider<BaseServiceProvider> myServiceProviderGeter(BaseServiceProvider baseServiceProvider) const
{
return MyServiceProvider<BaseServiceProvider>(baseServiceProvider, this->myMember2, this->myMember3);
}
};
...
ServiceProvider1 sp(...);
Servive1 service1(sp);
Service8 service8(sp);
Service9 service9(sp);
...
оттуда
+76
try {
IntToStr(pageid);
}
catch (...) {
pageid = 0;
}
А вдруг?
+10
align.h:
#pragma once
#include "stdint.h"
namespace tblib
{
template <typename T>
struct check_align
{
uint8_t c;
T t;
check_align();
check_align(const check_align&);
check_align&operator=(const check_align&);
};
template <typename T>
struct align_value
{
enum { value = sizeof(check_align<T>)-sizeof(T) };
};
template <int N>
struct align_by_size;
template <>
struct align_by_size<1> { uint8_t guts; };
template <>
struct align_by_size<2> { uint16_t guts; };
template <>
struct align_by_size<4> { uint32_t guts; };
template <>
struct align_by_size<8> { uint64_t guts; };
template <typename T>
struct align
{
align_by_size<align_value<T>::value> guts;
};
};
класс массива (начало), файл tbarr.h:
#pragma once
#include "stdint.h"
#include "assert.h"
#include <algorithm>
#include "tbslice.h"
#include "align.h"
// FUCK THE EXCEPTIONS
template <typename T>
void construct (T* first, T* last) {
while (first!=last) {
new(first) T;
++first;
}
}
template <typename T>
void destroy (T* first, T* last) {
while (last!=first) {
--last;
last->~T();
}
}
namespace tblib
{
template <typename T, int N>
class base_array
{
union
{
uint8_t memory [sizeof(T[N])];
align<T> aligner;
};
public :
мой выравниватель
намного красивее бустовского, не так ли?
+1
struct Vector2f{float x, y;};
struct Vector3f{float x, y, z;};
struct Tensor3f{float xx, xy, xz, yy, yz, zz;};
struct Matrix3x3f{float data[9];};
struct Space2
{
typedef Vector2f Vector;
};
struct Space3
{
typedef Vector3f Vector;
};
template<typename Space>
struct ParticleSystem
{
template<typename T>
struct ParticleData{};
template<>
struct ParticleData<Space2>
{
float orientation;
float invInertia;
};
template<>
struct ParticleData<Space3>
{
typename Matrix3x3f orientation;
typename Tensor3f inertiaTensor;
};
struct Particle : public ParticleData<Space>
{
typename Space::Vector pos, velocity;
};
template<typename T>
void DumpParticle(){}
template<>
void DumpParticle<Space2>()
{
printf("%f %f", particles[0].orientation, particles[0].invInertia);
}
template<>
void DumpParticle<Space3>()
{
printf("%f %f", particles[0].orientation.data[0], particles[0].inertia.xx);
}
void DumpParticles()
{
DumpParticle<Space>();
}
std::vector<Particle> particles;
};
Хочу объединить трехмерный и двухмерный движок.