constexpr Class Builder :: 4programmers.net

mwl4

2022-12-14 23:02

mwl42022-12-14 23:02

Rejestracja:około 12 lat
Ostatnio:22 dni
Lokalizacja:Wrocław
Postów:399

Cześć,

próbuję stworzyć class buildera, który rozpakuje mi się do parametrów template'a.

Powiedzmy, że mam taką klasę:

Kopiuj

enum class PrinterOption
{
    NotSet = 0,
    ToStdout,
    ToFile,
};

template< PrinterOption V1, int V2, int V3, bool V4, int V5 >
class Printer
{
public:
    static void SomeHotFunction()
    {
        if( V1 == PrinterOption::ToStdout )
        {
            printf( "SomeHotFunction - PrinterOption::ToStdout, V2 = %d, V3 = %d, V4 = %d, V5 = %d\n", V2, V3, V4, V5 );
        }
        else if( V1 == PrinterOption::ToFile )
        {
            printf( "SomeHotFunction - PrinterOption::ToFile, V2 = %d, V3 = %d, V4 = %d, V5 = %d\n", V2, V3, V4, V5 );
        }
        else
        {
            abort();
        }
    }
};

i mam do niej buildera:

Kopiuj

class PrinterBuilder
{
public:
    constexpr PrinterBuilder()
    {
    }

    constexpr PrinterBuilder &SetToStdout( int v2, int v3 )
    {
        m_v1 = PrinterOption::ToStdout;
        m_v2 = v2;
        m_v3 = v3;
        return *this;
    }

    constexpr PrinterBuilder &SetToFile( bool v4, int v5 )
    {
        m_v1 = PrinterOption::ToFile;
        m_v4 = v4;
        m_v5 = v5;
        return *this;
    }

    constexpr auto GetTuple() const
    {
        return std::make_tuple( m_v1, m_v2, m_v3, m_v4, m_v5 );
    }

public:
    PrinterOption m_v1 = PrinterOption::NotSet;
    int m_v2 = 1;
    int m_v3 = 4;
    bool m_v4 = false;
    int m_v5 = 10;
};

i przykładowe użycie:

Kopiuj

int main()
{
    static constexpr auto p1 = PrinterBuilder().SetToStdout( 100, 200 ).GetTuple();
    using Printer1 = Printer< std::get< 0 >( p1 ), std::get< 1 >( p1 ), std::get< 2 >( p1 ), std::get< 3 >( p1 ), std::get< 4 >( p1 ) >;
    Printer1::SomeHotFunction();

    static constexpr auto p2 = PrinterBuilder().SetToFile( true, 10000 ).GetTuple();
    using Printer2 = Printer< std::get< 0 >( p2 ), std::get< 1 >( p2 ), std::get< 2 >( p2 ), std::get< 3 >( p2 ), std::get< 4 >( p2 ) >;
    Printer2::SomeHotFunction();

    return 0;
}

Otóż potrzebuję generalnego rozwiązania do tego kawałka kodu:

Kopiuj

static constexpr auto p2 = PrinterBuilder().SetToFile( true, 10000 ).GetTuple();
using Printer2 = Printer< std::get< 0 >( p2 ), std::get< 1 >( p2 ), std::get< 2 >( p2 ), std::get< 3 >( p2 ), std::get< 4 >( p2 ) >;

konkretnie to potrzebuję jakiejś magii, która sprawi, że parametry z std::tuple rozpakują mi się w miejscu parametrów szablonowych.

Coś takiego:

Kopiuj

    static constexpr auto p2 = PrinterBuilder().SetToFile( true, 10000 ).GetTuple();
    using Printer2 = Printer< MAGIA( p2 ) >;

A jakby dało się zrobić jeszcze coś takiego:

Kopiuj

    using Printer2 = Printer< MAGIA( PrinterBuilder().SetToFile( true, 10000 ) ) >;

To już w ogóle byłbym wniebowzięty.

Uprzedzając pytania, odpowiadam po co mi to w ogóle jest potrzebne.

Nie mogę przenieść parametrów szablonowych do składowej klasy, powiedzmy:

Kopiuj

class Printer
{
    PrinterOption V1;
    int V2;
    int V3;
    bool V4;
    int V5;

Bo wtedy ta funkcja:

Kopiuj

static void SomeHotFunction()
{
    if( V1 == PrinterOption::ToStdout )

będzie miała warunek w runtime.

Z parametrami szablonowymi ta funkcja wygląda bardzo prosto w asm:

Kopiuj

call    Printer<(PrinterOption)1, 100, 200, false, 10>::SomeHotFunction()

Kopiuj

        .string "SomeHotFunction - PrinterOption::ToStdout, V2 = %d, V3 = %d, V4 = %d, V5 = %d\n"
Printer<(PrinterOption)1, 100, 200, false, 10>::SomeHotFunction():
        push    rbp
        mov     rbp, rsp
        mov     r8d, 10
        mov     ecx, 0
        mov     edx, 200
        mov     esi, 100
        mov     edi, OFFSET FLAT:.LC0
        mov     eax, 0
        call    printf
        nop
        pop     rbp
        ret

Brak warunków, prosty kod do wykonania.
Parametry mogą być złożone, więc może być wiele warunków do nich i dodatkowo pamięć parametrów może nie być w cache. Wszystkie parametry są znane w czasie kompilacji, jedynie miejsc użycia klasy Printer<> może być bardzo wiele.

Założeniem systemu jest to, że funkcja SomeHotFunction() (która dodatkowo będzie zinlineowana) będzie wołana na serwerze przynajmniej 80000000 razy na sekundę na wielu wątkach przypiętych do rdzeni i nie da się tego uniknąć.

Czy to jest w ogóle możliwe, żeby to zrobić?

Godbolt: https://godbolt.org/z/ccYvrohG6

edytowany 1x, ostatnio: mwl4 2022-12-14 23:08

_13th_Dragon

2022-12-14 23:17

_13th_Dragon2022-12-14 23:17

Rejestracja:prawie 20 lat
Ostatnio:8 dni

Widzę że nie pojąłeś idei buildera.
Czy klasa Printer to twoja klasa?
Jakie ma konstruktory?

mwl4 2022-12-14 23:26

Usage examples: It’s especially useful when you need to create an object with lots of possible configuration options.

The Builder pattern can be recognized in a class, which has a single creation method and several methods to configure the resulting object. Builder methods often support chaining

https://refactoring.guru/design-patterns/builder/php/example Wydało mi się to najbliżej tej idei. Generalnie tych opcji konfiguracji może być sporo i dlatego raczej potrzebuję buildera (choć widzę też inne opcje, ale mniej przyjazne dla usera frameworka).

mwl4

2022-12-14 23:24

mwl42022-12-14 23:24

Rejestracja:około 12 lat
Ostatnio:22 dni
Lokalizacja:Wrocław
Postów:399

Nazwałem to builderem bo to najbliżej jest tej koncepcji.

Ja piszę framework, który będzie używany w całej aplikacji.

Klasa Printer jest częścią frameworka i sterowanie ma być oddane userowi (przez parametry).

_13th_Dragon

2022-12-14 23:48

_13th_Dragon2022-12-14 23:48

Rejestracja:prawie 20 lat
Ostatnio:8 dni

W języku bez refleksji stworzenie uniwersalnego jest nie do przebrnięcia.
Więc zwyczajnie o ile chcesz mieć builder to wygląda to jakoś tak:

Kopiuj

#include <iomanip>
#include <iostream>
#include <vector>
#include <cctype>
#include <cstdlib>
using namespace std;

enum class PrinterOption:uint8_t
{
    NotSet = 0,
    ToStdout,
    ToFile,
};

ostream &operator<<(ostream &s,const PrinterOption &p)
{
	if(p==PrinterOption::ToStdout) s<<"ToStdout";
	else if(p==PrinterOption::ToFile) s<<"ToFile";
	else s<<"NotSet";
	return s;
}

class Printer
{
	public:
	static void call(PrinterOption V1,int V2,int V3,bool V4,int V5) 
	{
		cout<<"------------"<<endl;
		cout<<"V1="<<V1<<';'<<endl;
		cout<<"V2="<<V2<<';'<<endl;
		cout<<"V3="<<V3<<';'<<endl;
		cout<<"V4="<<V4<<';'<<endl;
		cout<<"V5="<<V5<<';'<<endl;
		cout<<endl;
	}
};

class Builder
{
	private:
	PrinterOption V1;
	int V2,V3;
	bool V4;
	int V5;
	public:
	Builder():V1(PrinterOption::NotSet),V2(100),V3(200),V4(false),V5(10) {} //default options
	Builder &setV1(PrinterOption V1) { this->V1=V1; return *this; }
	Builder &setV2(int V2)           { this->V2=V2; return *this; }
	Builder &setV3(int V2)           { this->V3=V3; return *this; }
	Builder &setV4(bool V4)          { this->V4=V4; return *this; }
	Builder &setV5(int V5)           { this->V5=V5; return *this; }
	Printer call()const { return Printer::call(V1,V2,V3,V4,V5); }
};

int main()
{
	Builder builder;
	Printer p1=builder.setV1(PrinterOption::ToStdout).setV5(11).call();
	Printer p2=builder.setV1(PrinterOption::ToFile).setV4(true).call();
	Printer p3=builder.setV2(666).setV3(13).call();
	return 0;
}

edytowany 1x, ostatnio: _13th_Dragon 2022-12-15 00:02

Zobacz pozostałe 4 komentarze

mwl4 2022-12-15 00:02

Bardziej bym się skupił na znalezieniu odpowiedzi na pierwotne pytanie niż na zgłębianiu architektury. W poście opiszę trochę więcej o co tu chodzi, ale też nie podam wszystkich szczegółów - nie jestem w stanie, system jest bardzo duży i dosyć skomplikowany.

mwl4 2022-12-15 00:04

Po modyfikacji, gdzie dodałeś funkcję call - problem jest taki, że parametry teraz muszą być podane do funkcji. A to framework woła tą funkcję i nie wie jakie są parametry użytkownika.

_13th_Dragon 2022-12-15 00:05

Skoro nie wie to nie może wywołać, chyba proste no nie?

mwl4 2022-12-15 00:06

No nie do końca. Bo framework wie co wywołać, on podaje swoje parametry (ale to jest nieistotne, możemy nawet założyć, że nie podaje żadnych). A user swoje. I framework zrobi to co użytkownik uzna za najbardziej słuszne.

_13th_Dragon 2022-12-15 00:07

Dobra, dla mnie OUT dopóki nie wytłumaczysz sensownie o co ci chodzi.

mwl4

2022-12-15 00:37

mwl42022-12-15 00:37

Rejestracja:około 12 lat
Ostatnio:22 dni
Lokalizacja:Wrocław
Postów:399

Ok, trzeba więcej szczegółów.

Buduję framework do replikacji obiektów w grze sieciowej.

Gra obsługuje wiele klientów w jednym czasie (4000) i jest to gra symulacyjna. Do systemu wchodzić może nawet 50000 obiektów, które się składają z różnych właściwości (składowych).

Aby móc sobie pozwolić na tyle połączeń jednocześnie i tyle obiektów do replikacji, trzeba sensownie zarządzać systemem replikacji. Nie wchodząc za bardzo w szczegóły, framework musi mieć kod wynikowy, który zrobi robotę jak najszybciej. Każda najmniejsza rzecz, którą dodamy do Hot funkcji będzie spowalniać cały system o milisekundy, na co sobie nie możemy pozwolić (ramka trwa 16 ms, jak się nie zmieścimy w ramce to bardzo źle).

Aby replikować obiekty z serwera do klienta, najczęściej robi się to refleksją (tzn ma to sens, przetestowane w boju - tak to robią duże silniki gier).

Zbudowanie refleksji to żaden problem. Kod, który serializuje obiekty, robi delta compression, można wygenerować z szablonów i będzie on ładnie poinlineowany, bez virtual calli, dobrze zarządzany.

Powiedzmy, że mamy encję aktora, który ma ilość życia (user code):

Kopiuj

// user code
class Actor
{
public:
  int m_health;
};

Refleksję do replikacji dla tego aktora można stworzyć tak:

Kopiuj

// user code
REPLICATION_CLASS_BEGIN( Actor )
  REPLICATION_PROPERTY( m_health );
REPLICATION_CLASS_END;

Framework w środku ma obsługę dla różnych typów.

Kopiuj

// framework
template< typename T >
class TypeSerializer
{
public:
  static void Serialize( BitStream &bs, T &value );

  // takich funkcji jest więcej, do różnych dziwnych rzeczy związanych z replikacją
};

Obsługa jest realizowana przez specjalizację klasy powyżej.

Kopiuj

// framework
template<>
class TypeSerializer< int >
{
public:
  static void Serialize( BitStream &bs, int &value )
  {
     // jakis kod serializujący dane
  }
};

REPLICATION_PROPERTY( m_health ); w zasadzie w pewien sposób tworzy możliwość dla frameworka do tego aby zawołać TypeSerializer< int >::Serialize(). Nie będę pokazywał jak - nie jest to jakaś czarna magia.

Cały problem w tym, że użytkownik doskonale wie jaką charakterystykę ma m_health a framework tego nie wie (bo skąd).
Można by było wtłoczyć do frameworka parametry określające jak framework ma serializować m_health.

Kopiuj

REPLICATION_PROPERTY( m_health ).ReplicateWithBitsCount( 5 ); // 5 bitów wystarczy

Pytanie, jak zrobić, żeby wtłoczyć tą wartość do frameworka.

Myślałem, żeby wtłaczać to mniej więcej tak:

Kopiuj

// framework
template< typename T, typename Settings >
class TypeSerializer
{
public:
  static void Serialize( BitStream &bs, T &value );

  // takich funkcji jest więcej, do różnych dziwnych rzeczy związanych z replikacją
};

// framework
template< int BitsCount = 32 >
class TypeSerializer_int_Settings
{
public:
  static constexpr int c_bitsCount = BitsCount;
};

class TypeSerializer_int_Settings_Builder
{
public:
  constexpr TypeSerializer_int_Settings_Builder & ReplicateWithBitsCount( int bitsCount )
  {
    m_bitsCount = bitsCount;
    return *this;
  }

  int m_bitsCount;
};

// framework
template< typename Settings = TypeSerializer_int_Settings<> >
class TypeSerializer< int, Settings >
{
public:
  // Implementacja
  static void Serialize( BitStream &bs, int &value )
  {
    bs.WriteWithBits( value, Settings::c_bitsCount /* wtłoczone */ );
  }
};

Nie pytam jak ogarnąć to makro REPLICATION_PROPERTY, bo to ogarnę tak lub inaczej.

Ogólnie, to framework woła TypeSerializer<>::Serialize wtedy kiedy trzeba zreplikować obiekt do peera. Zadaniem usera frameworku jest to aby odpowiednio opisać klasy obieków refleksją i dodać obiekty do replikacji. Resztą zajmuje się framework.

edytowany 3x, ostatnio: mwl4 2022-12-15 01:00

_13th_Dragon

2022-12-15 00:52

_13th_Dragon2022-12-15 00:52

Rejestracja:prawie 20 lat
Ostatnio:8 dni

Wg mnie szukasz tego co proponuje boost::archive czyli serializacja i deserializacja.
Owszem możesz to skopiować z boosta i przerobić na strumień bitów, ale z autopsji wiem że nie tędy droga.
Nie wiem czy rozumiesz że jak zaczniesz wchodzić w kodowanie bitowe to cały process bardzo się spowolni.

mwl4 2022-12-15 00:56

Replikacja w silniku gry to jest dużo bardziej skomplikowany temat niż po prostu serializacja/deserializacja. Framework już jest napisany, działa, performance odpowiedni. Brakuje jeszcze kilku ficzerów, w tym te ustawienia replikacji per property. Stąd szukam sposobu na ułatwienie definiowania tych ustawień dzięki builderowi i przekonwertowaniu jakoś wyniku buildera do parametrów template'a.

_13th_Dragon 2022-12-15 01:00

Zawsze możesz serializować/deserealizować do/z stringstream więc masz replikacje załatwioną na wszelkie sposoby. Zawsze możesz zastąpić klasę na listę wartości/property/(jak zwał tak zwał) z tym że później nie łatwo z tym się pracuje.

mwl4 2022-12-15 01:03

Nie mam. Chociażby dlatego, że replikacja musi też być zoptymalizowana pod kątem zużycia przepustowości sieci (b/s). Więc wchodzi tu temat jak robić delta compression per property. Jak się robi takie rzeczy to: https://gafferongames.com/post/snapshot_compression/

_13th_Dragon 2022-12-15 01:04

To tak jak powiedziałem w poście, weź pomysł z boost'a przerób na strumień bitów i po krzyku.

mwl4 2022-12-15 01:07

Co to znaczy pomysł z boosta? Jak boost rozwiązuje problem customowej serializacji np. integera?

_13th_Dragon 2022-12-15 01:08

Przeczytaj uważnie ten post, użyj google by znaleźć

mwl4 2022-12-15 01:16

Zmiana architektury nie odpowiada na pytanie z pierwszego posta. Zmiana architektury też już nie wchodzi w grę. Replikacja to dużo szerszy problem niż zwykła serializacja i nie można myśleć o niej w taki sposób jak boost ma zaimplementowany boost::archive. Taki framework musi też wspierać np RPC w obiektach. Najlepiej by było jednak znaleźć sposób na budowanie parametrów szablonu albo wtłoczyć dane innym sposobem (np przez zapodanie klasy).

_13th_Dragon 2022-12-15 01:28

To się nazywa zakuty łeb ... :/

mwl4

2022-12-19 23:18

mwl42022-12-19 23:18

Rejestracja:około 12 lat
Ostatnio:22 dni
Lokalizacja:Wrocław
Postów:399

Dla potomnych: po kilku dniach wymyśliłem coś co daje mi zadowalający efekt.

Kopiuj

enum class PrinterOption
{
    NotSet = 0,
    ToStdout,
    ToFile,
};

template< PrinterOption V1 = PrinterOption::NotSet, int V2 = 200, int V3 = 300, bool V4 = false, int V5 = 400, int V6 = 0 >
class Printer
{
public:
    static void SomeHotFunction()
    {
        if( V1 == PrinterOption::ToStdout )
        {
            printf( "SomeHotFunction - PrinterOption::ToStdout, V2 = %d, V3 = %d, V4 = %d, V5 = %d, V6 = %d\n", V2, V3, V4, V5, V6 );
        }
        else if( V1 == PrinterOption::ToFile )
        {
            printf( "SomeHotFunction - PrinterOption::ToFile, V2 = %d, V3 = %d, V4 = %d, V5 = %d, V6 = %d\n", V2, V3, V4, V5, V6 );
        }
        else
        {
            printf( "SomeHotFunction = PrinterOption::NotSet, V2 = %d, V3 = %d, V4 = %d, V5 = %d, V6 = %d\n", V2, V3, V4, V5, V6 );
        }
    }
};

class PrinterBuilder
{
public:
    template< int V2, int V3 >
    class SetToStdout
    {
    };

    template< bool V4, int V5 >
    class SetToFile
    {
    };

    template< int V6 >
    class SetV6
    {
    };
};

// Implementation of PrinterBuilder::SetToStdout
template< PrinterOption V1, int V2, int V3, bool V4, int V5, int V6, int CV2, int CV3 >
constexpr inline Printer< PrinterOption::ToStdout, CV2, CV3, V4, V5, V6 > operator|( Printer< V1, V2, V3, V4, V5, V6 > p1, PrinterBuilder::SetToStdout< CV2, CV3 > p2 )
{
    return {};
}

// Implementation of PrinterBuilder::SetToFile
template< PrinterOption V1, int V2, int V3, bool V4, int V5, int V6, bool CV4, int CV5 >
constexpr inline Printer< PrinterOption::ToFile, V2, V3, CV4, CV5, V6 > operator|( Printer< V1, V2, V3, V4, V5, V6 > p1, PrinterBuilder::SetToFile< CV4, CV5 > p2 )
{
    return {};
}

// Implementation of PrinterBuilder::SetV6
template< PrinterOption V1, int V2, int V3, bool V4, int V5, int V6, int CV6 >
constexpr inline Printer< V1, V2, V3, V4, V5, CV6 > operator|(Printer< V1, V2, V3, V4, V5, V6 > p1, PrinterBuilder::SetV6< CV6 > p2 )
{
    return {};
}

int main()
{
    using Printer0 = decltype( Printer<>() );
    Printer0::SomeHotFunction();

    using Printer1 = decltype( Printer<>() | PrinterBuilder::SetToStdout< 100, 200 >() | PrinterBuilder::SetV6< 50 >() );
    Printer1::SomeHotFunction();

    using Printer2 = decltype( Printer<>() | PrinterBuilder::SetToFile< true, 10000 >() | PrinterBuilder::SetV6< 150 >() );
    Printer2::SomeHotFunction();

    using Printer3 = decltype( Printer<>() | PrinterBuilder::SetV6< 160 >() | PrinterBuilder::SetToFile< true, 11234 >() );
    Printer3::SomeHotFunction();
}

https://godbolt.org/z/qKfzqzT3E

Ale poszedłem jeszcze dalej i jeszcze bardziej to zgeneralizowałem, żeby móc podawać tylko typy (bez instancjonowania).

Kopiuj

template< typename ... Args >
class BuildPrinterImpl {};

template< typename Arg, typename ... Args >
class BuildPrinterImpl< Arg, Args... >
{
public:
    using Result = decltype( std::declval< typename BuildPrinterImpl< Args... >::Result >() | std::declval< Arg >() );
};

template<>
class BuildPrinterImpl<>
{
public:
    using Result = decltype( std::declval< Printer<> >() );
};

template< typename ... Args >
using BuildPrinter = typename BuildPrinterImpl< Args... >::Result;

int main()
{
    using Printer1 = BuildPrinter<
                                   PrinterBuilder::SetToStdout< 100, 200 >,
                                   PrinterBuilder::SetV6< 50 >
                                 >;
    Printer1::SomeHotFunction();

    using Printer2 = BuildPrinter<
                                   PrinterBuilder::SetToFile< true, 10000 >,
                                   PrinterBuilder::SetV6< 150 >
                                 >;
    Printer2::SomeHotFunction();
    
    using Printer3 = BuildPrinter<
                                   PrinterBuilder::SetV6< 160 >,
                                   PrinterBuilder::SetToFile< true, 11234 >
                                 >;
    Printer3::SomeHotFunction();

    using Printer4 = BuildPrinter<
                                   PrinterBuilder::SetToFile< true, 10000 >,
                                   PrinterBuilder::SetV6< 260 >
                                 >;
    Printer4::SomeHotFunction();

    return 0;
}

https://godbolt.org/z/d67rv639b

Ewentualnie BuildPrinter można zgeneralizować żeby przyjmowało jakąkolwiek klasę, nie tylko Printer:

Kopiuj

template< typename C, typename ... Args >
class ClassParamsBuilderImpl {};

template< typename C, typename Arg, typename ... Args >
class ClassParamsBuilderImpl< C, Arg, Args... >
{
public:
    using Result = decltype( std::declval< typename ClassParamsBuilderImpl< C, Args... >::Result >() | std::declval< Arg >() );
};

template< typename C >
class ClassParamsBuilderImpl< C >
{
public:
    using Result = decltype( std::declval< C >() );
};

template< typename C, typename ... Args >
using ClassParamsBuilder = typename ClassParamsBuilderImpl< C, Args... >::Result;

int main()
{
    using Printer1 = ClassParamsBuilder< Printer<>,
                                   PrinterBuilder::SetToStdout< 100, 200 >,
                                   PrinterBuilder::SetV6< 50 >
                                 >;
    Printer1::SomeHotFunction();

    using Printer2 = ClassParamsBuilder< Printer<>,
                                   PrinterBuilder::SetToFile< true, 10000 >,
                                   PrinterBuilder::SetV6< 150 >
                                 >;
    Printer2::SomeHotFunction();
    
    using Printer3 = ClassParamsBuilder< Printer<>,
                                   PrinterBuilder::SetV6< 160 >,
                                   PrinterBuilder::SetToFile< true, 11234 >
                                 >;
    Printer3::SomeHotFunction();

    using Printer4 = ClassParamsBuilder< Printer<>,
                                   PrinterBuilder::SetToFile< true, 10000 >,
                                   PrinterBuilder::SetV6< 260 >
                                 >;
    Printer4::SomeHotFunction();

    return 0;
}

Oczywiście parametrami można sterować użyciem takiej liczby setterów jaką chcemy (i kolejność nie ma znaczenia):

Kopiuj

    using Printer1 = ClassParamsBuilder< Printer<>,
                                   PrinterBuilder::SetV1< PrinterOption::ToStdout >,
                                   PrinterBuilder::SetV4< false >,
                                   PrinterBuilder::SetV3< 11111 >,
                                   PrinterBuilder::SetV6< 50 >
                                 >;
    Printer1::SomeHotFunction();

Wyświetla:

Kopiuj

SomeHotFunction - PrinterOption::ToStdout, V2 = 200, V3 = 11111, V4 = 0, V5 = 400, V6 = 50

https://godbolt.org/z/q41vfrrEP

Działa na gcc, msvc, clang.

Liczba odpowiedzi na stronę

Zarejestruj się i dołącz do największej społeczności programistów w Polsce.

Otrzymaj wsparcie, dziel się wiedzą i rozwijaj swoje umiejętności z najlepszymi.

Utwórz konto

constexpr Class Builder

mwl4

_13th_Dragon

mwl4

_13th_Dragon

mwl4

_13th_Dragon

mwl4

PHP + Codeigniter 4 programista, aplikacja do fakturowania

React Frontend Developer

DevOps Engineer - migracja serwerów (Kubernetes,Docker,RoR)

Praca dla programistów

Forum dyskusyjne

Sprawy administracyjne

O nas

Skontaktuj się z nami