- 1
- 2
- 3
- 4
- 5
template<typename T>
concept Addable = requires (T x) { x + x; }; // requires-expression
template<typename T> requires Addable<T> // requires-clause, not requires-expression
T add(T a, T b) { return a + b; }
Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
+3
template<typename T>
concept Addable = requires (T x) { x + x; }; // requires-expression
template<typename T> requires Addable<T> // requires-clause, not requires-expression
T add(T a, T b) { return a + b; }
все решено.. перехожу писать код на "конецепты"
+3
class Person {
protected name: string;
constructor(name: string) { this.name = name; }
}
class Employee extends Person {
private department: string;
constructor(name: string, department: string) {
super(name);
this.department = department;
}
public get ElevatorPitch() {
return `Hello, my name is ${this.name} and I work in ${this.department}.`;
}
}
const howard = new Employee("Howard", "Sales");
console.log(howard.ElevatorPitch);
//===============================================>>>>>>>>>>>>>>>>>>
#ifndef TEST_H
#define TEST_H
#include "core.h"
using namespace js;
class Person;
class Employee;
class Person : public object, public std::enable_shared_from_this<Person> {
public:
string name;
Person(string name);
};
class Employee : public Person, public std::enable_shared_from_this<Employee> {
public:
string department;
Employee(string name, string department);
virtual any get_ElevatorPitch();
Employee(string name);
};
extern std::shared_ptr<Employee> howard;
#endif
#include "test.h"
using namespace js;
Person::Person(string name) {
this->name = name;
}
Employee::Employee(string name, string department) : Person(name) {
this->department = department;
}
any Employee::get_ElevatorPitch()
{
return "Hello, my name is "_S + this->name + " and I work in "_S + this->department + "."_S;
}
Employee::Employee(string name) : Person(name) {
}
std::shared_ptr<Employee> howard = std::make_shared<Employee>("Howard"_S, "Sales"_S);
void Main(void)
{
console->log(howard->get_ElevatorPitch());
}
int main(int argc, char** argv)
{
Main();
return 0;
}
Было делать нехрен в жизни и решил наговнокодить транспайлер с TypeScript в С++
https://github.com/ASDAlexander77/TypeScript2Cxx
+1
template<typename CharType>
class Formatter
{
private:
static int _ToString(Int32 Value){
return CString<CharType>::Snprintf(
(CharType*)GSupportToStringBuffer,
TO_STRING_BUFFER_SIZE,
"%" PRId32,
Value);
}
static int _ToString(float Value){
return CString<CharType>::Snprintf(
(CharType*)GSupportToStringBuffer,
TO_STRING_BUFFER_SIZE,
"%f",
Value);
}
template<typename First, typename ... Args>
static void _ConvertArgs(Array<GenericString<CharType>>& _ArgBuffer, const First& _First, const Args& ... _Args) {
_ArgBuffer.Add(ToString(_First));
_ConvertArgs(_ArgBuffer, _Args ...);
}
template<typename First>
static void _ConvertArgs(Array<GenericString<CharType>>& _ArgBuffer, const First& _First) {
_ArgBuffer.Add(ToString(_First));
}
static bool _ScanPlaceholder(const CharType* Format, size_t Index, size_t Length, size_t& Placeholder, size_t& LastIndex) {
size_t i = Index;
size_t j = 0;
while (i < Length && Format[i] != FormatterPlaceholder<CharType>::End)
{
if (!Char<CharType>::IsDigit(Format[i]))
{
return false;
}
else
{
GSupportToStringBuffer[j] = Format[i];
j++;
}
i++;
}
if (i == Length)
return false;
GSupportToStringBuffer[j] = 0;
#if defined(64BIT)
Placeholder = CString<CharType>::Atoi64((const CharType*)GSupportToStringBuffer);
#else
Placeholder = CString<CharType>::Atoi((const CharType*)GSupportToStringBuffer);
#endif
LastIndex = i;
return true;
}
public:
template<typename T>
static GenericString<CharType> ToString(const T& Value) {
int Length = Formatter<CharType>::_ToString(Value);
return GenericString<CharType>((char*)GSupportToStringBuffer, Length);
}
template<typename ... Args>
static GenericString<CharType> Format(const CharType* Format, const Args& ... _Args) {
Array<GenericString<CharType>> _FormatedArgs;
_FormatedArgs.Reserve(sizeof...(Args));
Formatter<CharType>::_ConvertArgs(_FormatedArgs, _Args ...);
const size_t _Length = CString<CharType>::Strlen(Format);
size_t Index = 0;
for (size_t i = 0; i < _Length; i++)
{
if (Format[i] == FormatterPlaceholder<CharType>::Begin)
{
size_t Placeholder = 0;
size_t LastIndex = 0;
if (_ScanPlaceholder(Format, i + 1, _Length, Placeholder, LastIndex) && Placeholder < sizeof...(Args))
{
Memory::Copy(GSupportFormatBuffer + Index, _FormatedArgs[Placeholder].Data(), _FormatedArgs[Placeholder].Length() * sizeof(CharType));
Index += _FormatedArgs[Placeholder].Length();
i = LastIndex;
}
}
else
{
GSupportFormatBuffer[Index] = Format[i];
Index++;
}
}
GSupportFormatBuffer[Index] = 0;
return GenericString<CharType>((const CharType*)GSupportFormatBuffer);
}
};
template<typename T>
forceinline String ToString(const T& Value){
return Formatter<char>::ToString<T>(Value);
}
template<typename ... Args>
forceinline String Format(const char* Format, const Args& ... _Args){
return Formatter<char>::Format(Format, _Args ...);
}
Три года назад писал printf аля Console.WriteLine в C#. Тут порезал до ста строк. https://pastebin.com/8BCLuBEm
0
struct Base { virtual const char *getName() = 0; virtual ~Base() = default; };
struct SE_0 : Base { virtual const char *getName() override { return "SE_0"; } };
struct SE_1 : Base { virtual const char *getName() override { return "SE_1"; } };
struct SE_2 : Base { virtual const char *getName() override { return "SE_2"; } };
enum TypesEnum {
E__BEGIN = 0,
E_0 = E__BEGIN,
E_1,
E_2,
E__END
};
template<TypesEnum>
struct Registry {};
template<>
struct Registry<E_0> {
static constexpr const char *name = "The first type (SE_0)";
using type = SE_0;
};
template<>
struct Registry<E_1> {
static constexpr const char *name = "A second type (SE_1)";
using type = SE_1;
};
template<>
struct Registry<E_2> {
static constexpr const char *name = "And the last type (SE_2)";
using type = SE_2;
};
template<TypesEnum CurrentType>
std::unique_ptr<Base> createTypeImpl(const char *name)
{
if constexpr (CurrentType < E__END) {
if (strstr(Registry<CurrentType>::name, name)) {
return std::make_unique<typename Registry<CurrentType>::type>();
}
return createTypeImpl<static_cast<TypesEnum>(CurrentType + 1)>(name);
} else {
(void)name; // Silence 'unreferenced formal parameter' warning
return nullptr;
}
}
std::unique_ptr<Base> createType(const char *name)
{
return createTypeImpl<E__BEGIN>(name);
}
int main()
{
std::cout << "first type: " << createType("first type")->getName() << std::endl;
std::cout << "second type: " << createType("second type")->getName() << std::endl;
std::cout << "last type: " << createType("last type")->getName() << std::endl;
return EXIT_SUCCESS;
}
Упоролся.
https://ideone.com/c11fz4
+1
https://habr.com/ru/post/497114/
А, кстати о темплейтах. Рабочий проект, где каждый .cpp-файл компилируется по 5-7
минут даже без оптимизаций? Время до первой диагностики компилятора в те же 5
минут? Пердёж компилятора на десятки мегабайт в случае ошибок? Да, я сохранял в
файл и замерял ради интереса. Потребление памяти компилятором в 5-10 гигов на
файл? Билдсервер с 32 ядрами и 64 гигами памяти, на которой нельзя запускать
больше чем этак 8 параллельных потоков компиляции? Проект на несколько десятков
kloc, собирающийся на ней полчаса? Получите, распишитесь.
И тулинг. Мне куда проще находить, на что у меня тратится память, в том же хаскеле,
который, как известно, только для факториалов и годится. Системы сборки? Ха. Апгрейд
компилятора для прода? Жди лет пять после релиза стандарта. Пакетный менеджер? Ха-ха.
Reproducible builds? Ха-ха-ха. Все места, где я работал, на это либо вообще забивали,
либо вкладывали какое-то совершенно неадекватное количество ресурсов. Я понимаю,
почему так происходит, у этого всего есть абсолютно логичные и объективные причины,
по-другому и выйти не могло, но я устал так жить.
Какой багор )))
+1
file:///C:/Users/сергейкомп/Desktop/проекты/desktopui_framework/src/core/formloader.cpp
+1
CStringUtf8::iterator& CStringUtf8::iterator::operator++()
{
m_ptr += CCharUtf8Ref::s_bytesForUTF8Sequence[*m_ptr];
return *this;
}
CStringUtf8 CStringUtf8::subString( size_t startChar, size_t count ) const
{
iterator start = this->begin();
while( start!=this->end() && startChar>0 )
{
start++;
startChar--;
}
iterator afterLast = start;
while( afterLast!=this->end() && count!=0 )
{
afterLast++;
count--;
}
return CStringUtf8( start.c_ptr(), afterLast.c_ptr() );
}
CStringUtf8::iterator CStringUtf8::findSubString( CStringUtf8 const& sample, CStringUtf8::iterator startFrom ) const
{
CStringUtf8::iterator pos = startFrom;
CStringUtf8::iterator foundPos = pos;
CStringUtf8::iterator samplePos = sample.begin();
for( ;; )
{
if( samplePos==sample.end() )
return foundPos;
if( pos==this->end() )
return this->end();
if( *samplePos == *pos )
{
if( samplePos==sample.begin() )
foundPos = pos;
samplePos++;
pos++;
}
else
{
if( samplePos==sample.begin() )
pos++;
samplePos = sample.begin();
}
}
}
std::vector<CStringUtf8> CStringUtf8::componentsSeparatedByString( CStringUtf8 const& separator ) const
{
std::vector<CStringUtf8> comps;
size_t sepLen = std::distance( separator.begin(), separator.end() );
size_t startPos = 0;
CStringUtf8::iterator itStart = begin();
if( sepLen > 0 )
{
CStringUtf8::iterator itEnd;
while( ( itEnd = findSubString( separator, itStart ) ) != end() )
{
size_t cnt = std::distance( itStart, itEnd );
CStringUtf8 str = subString( startPos, cnt );
comps.push_back( str );
itStart = itEnd;
std::advance( itStart, sepLen );
startPos += cnt + sepLen;
}
}
size_t cnt = std::distance( itStart, end() );
if( cnt > 0 )
{
CStringUtf8 str = subString( startPos, cnt );
comps.push_back( str );
}
return comps;
}
Привычный для всех плюсовиков велосипед по работе со строкой (походу свой в каждом проекте).
Более 10 лет не замечали тормоза в componentsSeparatedByString, который 100 Кб текст разбирал на строки за 5-10 сек (!!!).
+1
char *CHudTextMessage::LocaliseTextString( const char *msg, char *dst_buffer, int buffer_size )
{
char *dst = dst_buffer;
for ( char *src = (char*)msg; *src != 0 && buffer_size > 0; buffer_size-- )
{
if ( *src == '#' )
{
// cut msg name out of string
static char word_buf[255];
char *wdst = word_buf, *word_start = src;
for ( ++src ; *src >= 'A' && *src <= 'z'; wdst++, src++ )
{
*wdst = *src;
}
*wdst = 0;
Тут недавно слили исходники «Team Fortress 2» и «Counter Strike: Global Offense» — и в соответствующих местах начался вой игроков: кошмар, мы все умрём, нас всех взломают!
0
auto srv = http::Server::create(
JsClosure::create([] (JsArray::Ptr args) {
auto res = args->getPtr<http::ServerResponse>(1);
res->setHeader(http::HEADER_CONTENT_TYPE, str("text/plain"));
res->end(str("Hello World\n"));
return UNDEFINED;
}));
srv->listen(1337, str("127.0.0.1"));
node::run();
https://github.com/plenluno/libnode
Что если взять два говна (плюсы и js) и сделать свою ноду? Получится этот высер с потугами на embedded.
Неосилятор? Или переосилятор?
0
char* szOwnedData = reinterpret_cast <char*> (m_bOwner && szData != NULL ?
realloc (szData, nLength + 1) :
malloc (nLength + 1));
Ha ha, classic.