constexpr Class Builder :: 4programmers.net

mwl4

2022-12-14 23:02

mwl42022-12-14 23:02

Rejestracja:około 12 lat
Ostatnio:8 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:ponad 19 lat
Ostatnio:3 miesiące

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:8 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:ponad 19 lat
Ostatnio:3 miesiące

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:8 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:ponad 19 lat
Ostatnio:3 miesiące

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.

Zobacz pozostałe 3 komentarze

_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:8 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ę

Treść *

Treść

Podgląd

Kliknij, aby dodać treść...

Kliknij, aby dodać załącznik lub wklej ze schowka.

Instrukcja obsługi Markdown

Pomoc 1.18.8

Typografia

Edytor obsługuje składnie Markdown, w której pojedynczy akcent *kursywa* oraz _kursywa_ to pochylenie. Z kolei podwójny akcent **pogrubienie** oraz __pogrubienie__ to pogrubienie. Dodanie znaczników ~~strike~~ to przekreślenie.

Możesz dodać formatowanie komendami , , oraz .

Ponieważ dekoracja podkreślenia jest przeznaczona na linki, markdown nie zawiera specjalnej składni dla podkreślenia. Dlatego by dodać podkreślenie, użyj underline.

Komendy formatujące reagują na skróty klawiszowe: Ctrl+B, Ctrl+I, Ctrl+U oraz Ctrl+S.

Linki

By dodać link w edytorze użyj komendy lub użyj składni [title](link). URL umieszczony w linku lub nawet URL umieszczony bezpośrednio w tekście będzie aktywny i klikalny.

Jeżeli chcesz, możesz samodzielnie dodać link: <a href="link">title</a>.

Wewnętrzne odnośniki

Możesz umieścić odnośnik do wewnętrznej podstrony, używając następującej składni: [[Delphi/Kompendium]] lub [[Delphi/Kompendium|kliknij, aby przejść do kompendium]]. Odnośniki mogą prowadzić do Forum 4programmers.net lub np. do Kompendium.

Wspomnienia użytkowników

By wspomnieć użytkownika forum, wpisz w formularzu znak @. Zobaczysz okienko samouzupełniające nazwy użytkowników. Samouzupełnienie dobierze odpowiedni format wspomnienia, zależnie od tego czy w nazwie użytkownika znajduje się spacja.

Znaczniki HTML

Dozwolone jest używanie niektórych znaczników HTML: <a>, , , <kbd>, <del>, , <dfn>, <pre>, <blockquote>, <hr/>, ,  oraz <img/>.

Skróty klawiszowe

Dodaj kombinację klawiszy komendą notacji klawiszy lub skrótem klawiszowym Alt+K.

Reprezentuj kombinacje klawiszowe używając taga <kbd>. Oddziel od siebie klawisze znakiem plus, np <kbd>Alt+Tab</kbd>.

Indeks górny oraz dolny

Przykład: wpisując H2O i m2 otrzymasz: H₂O i m².

Składnia Tex

By precyzyjnie wyrazić działanie matematyczne, użyj składni Tex.

<tex>arcctg(x) = argtan(\frac{1}{x}) = arcsin(\frac{1}{\sqrt{1+x^2}})</tex>

Kod źródłowy

Krótkie fragmenty kodu

Wszelkie jednolinijkowe instrukcje języka programowania powinny być zawarte pomiędzy obróconymi apostrofami: `kod instrukcji` lub ``console.log(`string`);``.

Kod wielolinijkowy

Dodaj fragment kodu komendą . Fragmenty kodu zajmujące całą lub więcej linijek powinny być umieszczone w wielolinijkowym fragmencie kodu. Znaczniki ``` lub ~~~ umożliwiają kolorowanie różnych języków programowania. Możemy nadać nazwę języka programowania używając auto-uzupełnienia, kod został pokolorowany używając konkretnych ustawień kolorowania składni:

```javascript document.write('Hello World'); ```

Możesz zaznaczyć również już wklejony kod w edytorze, i użyć komendy by zamienić go w kod. Użyj kombinacji Ctrl+`, by dodać fragment kodu bez oznaczników języka.

Tabelki

Dodaj przykładową tabelkę używając komendy . Przykładowa tabelka składa się z dwóch kolumn, nagłówka i jednego wiersza.

Wygeneruj tabelkę na podstawie szablonu. Oddziel komórki separatorem ; lub |, a następnie zaznacz szablonu.

nazwisko;dziedzina;odkrycie
Pitagoras;mathematics;Pythagorean Theorem
Albert Einstein;physics;General Relativity
Marie Curie, Pierre Curie;chemistry;Radium, Polonium

Użyj komendy by zamienić zaznaczony szablon na tabelkę Markdown.

Lista uporządkowana i nieuporządkowana

Możliwe jest tworzenie listy numerowanych oraz wypunktowanych. Wystarczy, że pierwszym znakiem linii będzie * lub - dla listy nieuporządkowanej oraz 1. dla listy uporządkowanej.

Użyj komendy by dodać listę uporządkowaną.

1. Lista numerowana
2. Lista numerowana

Użyj komendy by dodać listę nieuporządkowaną.

* Lista wypunktowana
* Lista wypunktowana
** Lista wypunktowana (drugi poziom)

Składnia Markdown

Edytor obsługuje składnię Markdown, która składa się ze znaków specjalnych. Dostępne komendy, jak formatowanie , dodanie tabelki lub fragmentu kodu są w pewnym sensie świadome otaczającej jej składni, i postarają się unikać uszkodzenia jej.

Dla przykładu, używając tylko dostępnych komend, nie możemy dodać formatowania pogrubienia do kodu wielolinijkowego, albo dodać listy do tabelki - mogłoby to doprowadzić do uszkodzenia składni.

W pewnych odosobnionych przypadkach brak nowej linii przed elementami markdown również mógłby uszkodzić składnie, dlatego edytor dodaje brakujące nowe linie. Dla przykładu, dodanie formatowania pochylenia zaraz po tabelce, mogłoby zostać błędne zinterpretowane, więc edytor doda oddzielającą nową linię pomiędzy tabelką, a pochyleniem.

Skróty klawiszowe

Skróty formatujące, kiedy w edytorze znajduje się pojedynczy kursor, wstawiają sformatowany tekst przykładowy. Jeśli w edytorze znajduje się zaznaczenie (słowo, linijka, paragraf), wtedy zaznaczenie zostaje sformatowane.

Ctrl+B - dodaj pogrubienie lub pogrub zaznaczenie
Ctrl+I - dodaj pochylenie lub pochyl zaznaczenie
Ctrl+U - dodaj podkreślenie lub podkreśl zaznaczenie
Ctrl+S - dodaj przekreślenie lub przekreśl zaznaczenie

Notacja Klawiszy

Alt+K - dodaj notację klawiszy

Fragment kodu bez oznacznika

Alt+C - dodaj pusty fragment kodu

Skróty operujące na kodzie i linijkach:

Alt+L - zaznaczenie całej linii
Alt+, Alt+ - przeniesienie linijki w której znajduje się kursor w górę/dół.
Tab/⌘+] - dodaj wcięcie (wcięcie w prawo)
Shit+Tab/⌘+[ - usunięcie wcięcia (wycięcie w lewo)

Dodawanie postów:

Ctrl+Enter - dodaj post
⌘+Enter - dodaj post (MacOS)

constexpr Class Builder

mwl4

_13th_Dragon

mwl4

_13th_Dragon

mwl4

_13th_Dragon

mwl4

Smileys & People

Animals & Nature

Food & Drink

Travel & Places

Activities

Objects

Symbols

Typografia

Linki

Wewnętrzne odnośniki

Wspomnienia użytkowników

Znaczniki HTML

Skróty klawiszowe

Indeks górny oraz dolny

Składnia Tex

Kod źródłowy

Krótkie fragmenty kodu

Kod wielolinijkowy

Tabelki

Lista uporządkowana i nieuporządkowana

Składnia Markdown

Skróty klawiszowe

Java Developer

Data Scientist

Programista Systemów Automatyki - PCS7

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

Praca dla programistów

Forum dyskusyjne

Sprawy administracyjne

O nas

Skontaktuj się z nami