Hvis du i starten av stykket sier at det henger en kode på C++ på veggen, så må den nødvendigvis gå av i foten din på slutten.
Bjarne Stroustrup
Fra 31. oktober til 1. november fant konferansen C++ Russia Piter sted i St. Petersburg – en av de største programmeringskonferansene i Russland, organisert av JUG Ru Group. Blant de inviterte foredragsholderne var medlemmer av C++ standardiseringskomiteen, presentatører fra CppCon, forfattere av bøker fra forlaget O'Reilly, samt vedlikeholdere av prosjekter som LLVM, libc++ og Boost. Konferansen er rettet mot erfarne C++ utviklere som ønsker å dypere sin ekspertise og dele erfaring i levende kommunikasjon. Studenter, doktorgradsstudenter og universitetslærere får svært hyggelige rabatter.
Den moskva-baserte utgaven av konferansen vil finne sted allerede i april neste år, men inntil da vil studentene våre dele hva spennende de har lært på det nylig avholdte arrangementet.

Bilde fra
Om oss
To studenter fra HSE i St. Petersburg har jobbet med dette innlegget:
- Lisa Vasilenko – student på 4. året bachelorgrad, som studerer fagfeltet «Programmeringsspråk» innenfor programmet «Anvendt matematikk og informatikk». Etter å ha blitt kjent med C++ språket på sitt første år på universitetet, fikk hun senere erfaring med det gjennom praksisplasser i industrien. En interesse for programmeringsspråk generelt og funksjonell programmering spesielt har preget valget av foredragene på konferansen.
- Dania Smirnov – student på 1. året mastergrad i «Programmering og dataanalyse». Allerede i skolen løste han olympiske oppgaver med C++, og det skjedde sånn at språket stadig dukket opp i studiene og til slutt ble det hovedarbeidsverktøyet. Han bestemte seg for å delta i konferansen for å forbedre sine kunnskaper og lære om nye muligheter.
I nyhetsbrevet deler fakultetsledelsen ofte informasjon om utdanningsarrangementer relatert til vårt spesialfelt. I september så vi informasjon om C++ Russia og bestemte oss for å registrere oss som lyttere. Dette er vår første erfaring med å delta på slike konferanser.
Konferansens struktur
Foredrag
I løpet av to dager leste ekspertene 30 rapporter som belyste mange aktuelle emner: smart bruk av språkets funksjoner for å løse praktiske oppgaver, kommende oppdateringer av språket i forbindelse med den nye standarden, kompromisser i C++-design og forholdsregler ved arbeid med deres konsekvenser, eksempler på interessant prosjektarkitektur, samt noen underliggende detaljer i språkets infrastruktur. Samtidig foregikk det tre presentasjoner, oftest to på russisk og en på engelsk.
Diskusjonsområder
Etter presentasjonen ble alle ubesvarte spørsmål og uferdige diskusjoner overført til spesialdesignede kommunikasjonsområder med foredragsholderne, utstyrt med whiteboards. En fin måte å tilbringe pausen mellom presentasjonene på med hyggelig samtale.
Lightning Talks og uformelle diskusjoner
Hvis du ønsker å holde en kort presentasjon, kan du skrive deg opp på whiteboarden for en kveldslightning talk og få fem minutter til å snakke om hva som helst relatert til konferansens tema. For eksempel, en rask introduksjon til sanitizers for C++ (for noen var det nytt) eller en historie om en bug i genereringen av sinuskurver, som man kun kan høre, men ikke se.
Et annet format var paneldiskusjonen «Med komiteen til sjelespråking». På scenen var noen medlemmer av standardiseringskomiteen, på projektoren en peis (offisielt for å skape en koselig atmosfære, men grunnen «fordi ALT ER I BRANN» virker morsommere), spørsmålene handlet om standarden og det generelle synet på C++, uten stormfulle tekniske diskusjoner og krangler. Det viste seg at det også sitter levende mennesker i komiteen, som kanskje ikke er fullt sikre på alt eller som ikke vet noe.
For de som liker krangling, var det et tredje arrangement — BOF-sesjonen «Go mot C++». Vi tar en Go-entusiast, en C++-entusiast, og før sesjonen sammen lager de 100500 lysbilder om temaer (som problemer med pakker i C++ eller mangel på generiske typer i Go), og deretter diskuterer de livlig mellom seg og med salen, mens salen prøver å forstå to perspektiver samtidig. Hvis det begynner å bli en unødvendig krangel, griper moderator inn og forsoner partene. Dette formatet drar ut: flere timer etter starten var bare halvparten av lysbildene gjennomgått. Avslutningen måtte fremskyndes betydelig.
Partnerstand
I holene blei presentert konferansepartnarar – på stånda fortalte dei om aktuelle prosjekt, tilbød praksisplassar og ansetjing, gjennomførte quizar og små konkurransar, samt delte ut hyggelige premiar. Nokre selskap tilbød til og med å gjennomføre innleiande intervju, noko som kan vere nyttig for dei som ikkje berre kom for å høyre på innlegg.
Tekniske detaljar om innleggene
Vi følgde innleggene begge dagar. Av og til var det vanskeleg å velje eitt innlegg blant dei som gjekk parallelt – vi blei einige om å dele oss og bytte kunnskap i pausane. Likevel verkar det som om mykje har gått oss hus forbi. Her vil vi gjerne fortelja om innhaldet i nokre innlegg som vi syntest var mest interesante
Unntak i C++ gjennom linsa av kompilatoroptimaliseringar, Roman Rusjaev

Slide frå
Som tittelen antyder, såg Roman på arbeidet med unntak ved å bruke dømet frå LLVM. For dei som ikkje brukar Clang i sitt arbeid, kan innlegget likevel gi ei viss forståing av korleis koden potensielt kan bli optimalisert. Dette er slik fordi kompilatorutviklarar og dei tilhøyrande standardbibliotekene kommuniserer med kvarandre, og mange vellykka løysingar kan være like.
Så for å håndtere eit unntak krevst det mange handlingar: å kalle opp handteringskoden (hvis det finst) eller frigjere ressursar på det nåverande nivået og rulle opp stakken. Alt dette fører til at kompilatoren legg til ekstra instruksjonar for kall som potensielt kan utløse unntak. Så dersom eit unntak faktisk ikkje blir kalla, vil programmet likevel utføre unødvendige handlingar. For å redusere kostnadene, har LLVM flere heuristikker for å bestemme situasjonar der unntakshandteringskode ikkje trengst å leggast til, eller der antallet "unødvendige" instruksjonar kan reduserast.
Foredragsinhaldar vurderer om lag ti av dei og viser både situasjonar der dei bidrar til å akselerere programutføringa, og dei der desse metodane ikkje er anvendbare.
Dermed fører Roman Rusjaev lytarane til konklusjonen om at kode som inneheld arbeid med unntak langt frå alltid kan utførast med null kostnader, og gir følgjande råd:
- Når du utvikler biblioteker, bør du unngå unntak i utgangspunktet;
- Hvis unntak likevel er nødvendig, bør modifierne noexcept (og const) legges til der det er mulig, slik at kompilatoren kan optimalisere så mye som mulig.
Generelt bekreftet foredragsholderen meningen om at unntak bør brukes minst mulig, eller at man bør unngå dem helt.
Presentasjonslysene er tilgjengelige via lenken:
Generators, korutiner og annen hjernevending, Adi Shavit

Slide frå
En av mange foredrag på denne konferansen som omhandler nyvinninger i C++20, ble husket ikke bare på grunn av den fargerike presentasjonen, men også for den klare fremhevelsen av eksisterende problemer med logikken for håndtering av samlinger (for-løkker, callback-er).
Adi Shavit påpeker følgende: De eksisterende metodene går gjennom samlingen som helhet og gir ikke tilgang til en intern delvis tilstand (eller gir det i tilfelle av callback-er, men med mange uheldige bivirkninger, som Callback Hell). Det kan virke som om det finnes iteratorer, men selv med dem er ikke alt så glatt: det er ingen felles inngangs- og utgangspunkter (begin → end mot rbegin → rend osv.), og det er uklart hvor mange iterasjoner vi i det hele tatt vil ha? Fra og med C++20 løses disse problemene!
Første alternativ: ranges. Gjennom å pakke rundt iteratorene får vi et felles grensesnitt for start og slutt av iterasjonen, samt muligheten for sammensetning. Alt dette gjør det enkelt å bygge fullverdige databehandlingsrørledninger. Men ikke alt er så glatt: deler av logikken i beregningene ligger inne i implementasjonen av spesifikke iteratorer, noe som kan komplisere koden for opplevelse og feilsøking.

Slide frå
Vel, i så fall har C++20 lagt til korutiner (funksjoner hvis oppførsel ligner på generatorer i Python): utførelsen kan utsettes ved å returnere en viss nåverdi samtidig som man bevarer den delvise tilstanden. På denne måten oppnår vi ikke bare arbeid med data når de kommer, men også inkapslerer all logikk inne i den spesifikke korutinen.
Men det er en liten hake: for øyeblikket støttes de bare delvis av eksisterende kompilatorer, og de er heller ikke gjennomført så pent som man skulle ønske: for eksempel bør man foreløpig unngå å bruke referanser og midlertidige objekter i korutiner. I tillegg er det noen begrensninger på hva som kan være korutiner, og constexpr-funksjoner, konstruktører/destruktører og main er ikke inkludert i denne listen.
Dermed løser korutiner en betydelig del av problemene med enkelheten i databehandling, men deres nåværende implementeringer krever forbedringer.
Materialer:
- Lysbilder fra C++ Russia —
C++ triks fra Yandex.Taxi, Anton Polukhin
I sitt profesjonelle arbeid må man noen ganger implementere strengt hjelpende ting: et lag mellom et internt grensesnitt og API-en til et bibliotek, logging eller parsing. Vanligvis er det ikke behov for noen ekstra optimalisering. Men hva om disse komponentene brukes i noen av de mest populære tjenestene i Runet? I en slik situasjon må man håndtere terabyte med logger i timen! Da er hvert millisekund viktig, og derfor må man ty til ulike triks — om dem snakket Anton Polukhin.
Sannsynligvis var det mest interessante eksemplet implementeringen av mønsteret pointer-to-implementation (pimpl).
#include <third_party/json.hpp> //PROBLEMS!
struct Value {
Value() = default;
Value(Value&& other) = default;
Value& operator=(Value&& other) = default;
~Value() = default;
std::size_t Size() const { return data_.size(); }
private:
third_party::Json data_;
};I dette eksemplet vil man i begynnelsen kvitte seg med header-filene fra eksterne biblioteker — det vil både gjøre kompileringen raskere, og man kan beskytte seg mot mulige navnekonflikter og andre lignende feil.
Greit, vi flyttet #include til .cpp-filen: det er behov for forward-declaration av det innkapslede API’et, samt std::unique_ptr. Nå har vi dynamiske allokeringer og andre ubehagelige ting som spredte data på heapen og reduserte garantier. Med alt dette kan std::aligned_storage hjelpe.
struct Value {
// ...
private:
using JsonNative = third_party::Json;
const JsonNative* Ptr() const noexcept;
JsonNative* Ptr() noexcept;
constexpr std::size_t kImplSize = 32;
constexpr std::size_t kImplAlign = 8;
std::aligned_storage_t data_;
};Det eneste problemet: man må spesifisere størrelse og justering for hver innpakning — vi gjør vår pimpl til en mal med parameterne , bruker tilfeldige verdier, og legger til en sjekk i destruktøren for å sikre at vi har gjettet riktig:
~FastPimpl() noexcept {
validate();
Ptr()->~T();
}
template
static void validate() noexcept {
static_assert(
Size == ActualSize,
"Size and sizeof(T) mismatch"
);
static_assert(
Alignment == ActualAlignment,
"Alignment and alignof(T) mismatch"
);
}Siden det at destruktor T allerede er definert, vil denne koden bli behandlet korrekt og gi nødvendige størrelses- og justeringsverdier som må skrives inn, med nødvendige feil på kompileringstrinnet. Dermed, ved hjelp av et ekstra kompilasjonskjøring, unngår vi dynamisk allokering av omsluttede klasser, skjuler API i .cpp-filen med implementasjon, og oppnår en mer cache-vennlig struktur for prosessoren.
Logging og parsing virket mindre imponerende, så de vil ikke bli nevnt videre i denne oversikten.
Presentasjonslysene er tilgjengelige via lenken:
Moderne teknikker for å holde koden din DRY, Björn Fahller
I denne presentasjonen viser Björn Fahller flere forskjellige måter å takle stilistiske feil som gjentatte betingelsessjekker:
assert(a == IDLE || a == CONNECTED || a == DISCONNECTED);Kjent? Ved å bruke flere kraftige C++-teknikker fra de nyeste standardene kan man elegant implementere den samme funksjonaliteten uten minste ytelsestap. Sammenlign:
assert(a == any_of(IDLE, CONNECTED, DISCONNECTED));For å håndtere et varierende antall sjekker kreves det å bruke variadic templates og fold expressions. Anta at vi ønsker å sjekke likheten mellom flere variabler og enum-elementet state_type. Det første man tenker på, er å skrive en hjelpefunksjon is_any_of:
enum state_type { IDLE, CONNECTED, DISCONNECTED };
template
bool is_any_of(state_type s, const Ts& ... ts) {
return ((s == ts) || ...);
}
En slik mellomresultat skaper skuffelse. Så langt er ikke koden mer lesbar:
assert(is_any_of(state, IDLE, DISCONNECTING, DISCONNECTED)); Noen små justeringer kan gjøres med non-type template parameters. Vi kan bruke dem til å flytte enum-elementene inn i en liste av malparametere:
template
bool is_any_of(state_type t) {
return ((t == states) | ...);
}
assert(is_any_of(state)); Med bruk av auto som en non-type malparameter (C++17), utvides tilnærmingen til sammenligninger ikke bare med state_type-elementene, men også med primitive typer som kan brukes som non-type malparametere:
template
bool is_any_of(const T& t) {
return ((t == alternatives) | ...);
}Gjennom slike sekvensielle forbedringer oppnås ønsket flytende syntaks for kontroller:
template
struct any_of : private std::tuple {
// vi orker ikke og arver konstruktører fra tuple
using std::tuple::tuple;
template
bool operator ==(const T& t) const {
return std::apply(
[&t](const auto& ... ts) {
return ((ts == t) || ...);
},
static_cast<const std::tuple&>(*this));
}
};
template
any_of(Ts ...) -> any_of;
assert(any_of(IDLE, DISCONNECTING, DISCONNECTED) == state);
I dette eksempelet fungerer deduksjonsveiledningen for å foreslå de ønskede malparametrene for strukturen til kompilatoren, som kjenner typene på konstruktørargumentene.
Videre blir det mer interessant. Bjørn lærer å generalisere den resulterende koden for sammenligningsoperatorene og deretter for vilkårlige operasjoner. Samtidig blir slike funksjoner som no_unique_address attribute (C++20) og malparametre i lambda-funksjoner (C++20) forklart med eksempler. (Ja, nå er syntaksen for lambdas enda lettere å huske – det er fire påfølgende par med parenteser av alle sorter.) Den endelige løsningen som bruker funksjoner som byggeklosser for konstruktøren varmer faktisk mitt hjerte, for ikke å nevne uttrykket tuple i beste tradisjon av lambda-kalkulus.
Til slutt husk å pusse opp:
- La oss huske at lambdas er constexpr gratis;
- Vi legger til perfekt forwarding og ser på dens stygge syntaks i forhold til parameterpakker i lukking av lambdas;
- Vi gir kompilatoren flere muligheter for optimaliseringer med conditional noexcept;
- Vi sørger for mer forståelig feilmelding i malene takket være eksplisitte returverdier fra lambdas. Dette vil få kompilatoren til å gjøre flere sjekker før den faktisk kaller malfunksjonen – på typekontrollnivå.
For detaljer, vennligst se på forelesningsmaterialet:
- Presentasjonslysene:
Våre inntrykk
Vår første deltakelse i C++ Russia ble husket for sin intensitet. Inntrykket av C++ Russia er som et varmt arrangement der grensen mellom undervisning og levende samtale nesten ikke er merkbar. Alt, fra innstillingen til foredragsholderne til konkurransene fra arrangementets partnere, legger til rette for engasjerte diskusjoner. Innholdet i konferansen, som består av foredrag, dekker et ganske bredt spekter av emner, inkludert nyvinninger i C++, praktiske eksempler fra store prosjekter og ideologiske arkitektoniske betraktninger. Men det ville vært urettferdig å overse den sosiale komponenten av arrangementet, som hjelper til med å overvinne språkbarrierer i forhold til ikke bare C++.
Vi takker arrangørene av konferansen for muligheten til å delta på et slikt arrangement!
Innlegget fra arrangørene om fortid, nåtid og fremtid for C++ Russia kunne du se .
Takk for at du leste, og vi håper at vår oppsummering av hendelsene har vært nyttig!
Kilde: habr.com
