Printf

Kokeneet kirjoittajat eivät ole vielä tarkistaneet sivun nykyistä versiota, ja se voi poiketa merkittävästi 5. huhtikuuta 2015 tarkistetusta versiosta . tarkastukset vaativat 72 muokkausta .

printf ( englanniksi  print formatated , "muotoiltu tulostus") - yleinen nimi standardien tai tunnettujen kaupallisten kirjastojen funktioiden tai menetelmien perheelle tai joidenkin ohjelmointikielten sisäänrakennetuille operaattoreille, joita käytetään alustettuun tulosteeseen  - tulostetaan erityyppisiin arvovirtoihin , jotka on muotoiltu tietyn mallin mukaan. Tämä malli määräytyy erityissääntöjen mukaisesti muodostetun merkkijonon avulla (muotomerkkijono).

Tämän perheen merkittävin jäsen on printf -funktio sekä monet muut funktiot, jotka on johdettu Cprintf -standardin kirjaston nimistä (joka on myös osa C++- ja Objective-C- standardikirjastoja ).

UNIX -käyttöjärjestelmäperheessä on myös printf -apuohjelma , joka palvelee samoja alustettuja tulosteita.

Fortranin FORMAT - operaattoria voidaan pitää tällaisen toiminnon varhaisena prototyyppinä . Merkkijonopohjainen päättelyfunktio ilmestyi C-kielen edeltäjiin ( BCPL ja B ). C- standardikirjaston määrittelyssä se sai tunnetuimman muodonsa (liput, leveys, tarkkuus ja koko). Tulostusmallin merkkijonosyntaksia (jota joskus kutsutaan muotomerkkijonoksi , muotomerkkijonoksi tai muotomerkkijonoksi ) käytettiin myöhemmin muissa ohjelmointikielissä (muunnelmilla näiden kielten ominaisuuksien mukaan). Pääsääntöisesti näiden kielten vastaavia toimintoja kutsutaan myös printf :ksi ja/tai sen johdannaisiksi.

Jotkut uudemmat ohjelmointiympäristöt (kuten .NET ) käyttävät myös muotomerkkijonolähtöisen tulosteen käsitettä, mutta eri syntaksilla.

Historia

Ulkonäkö

Fortran Minulla oli jo operaattorit, jotka tarjosivat alustetun tulosteen. WRITE- ja PRINT -käskyjen syntaksi sisälsi etiketin, joka viittaa ei-suoritettavaan FORMAT -käskyyn , joka sisälsi muotomäärityksen. Määritykset olivat osa operaattorin syntaksia, ja kääntäjä pystyi välittömästi luomaan koodia, joka suorittaa suoraan tietojen muotoilun, mikä varmisti parhaan suorituskyvyn sen ajan tietokoneissa. Siinä oli kuitenkin seuraavat haitat:

• Komplikaatio kielen jo ennestään hämmentävästä syntaksista.
• Muotomääritystä ei voitu luoda ohjelman suorittamisen aikana.
• Muotomäärittely erotettiin tekstillisesti tuloslauseesta, mikä oli hankalaa ohjelmien ylläpidon kannalta.

Tulevan printf - toiminnon ensimmäinen prototyyppi ilmestyy BCPL - kielellä 1960 - luvulla . WRITEF -funktio ottaa muotomerkkijonon, joka määrittää tietotyypin erikseen itse tiedoista merkkijonomuuttujassa (tyyppi määritettiin ilman lippuja, leveys-, tarkkuus- ja kokokenttiä , mutta sitä edelsi jo prosenttimerkki ). [1] Muotomerkkijonon päätarkoitus oli välittää argumenttityyppejä (ohjelmointikielissä, joissa on staattinen kirjoitus funktiolle, jossa on ei-kiinteä muodollisten parametrien lista, hyväksytyn argumentin tyypin määrittäminen vaatii monimutkaista ja tehotonta mekanismia tyyppitietojen välittämiseksi yleisessä tapauksessa). WRITEF- funktio itsessään oli keino yksinkertaistaa tulostetta: funktiosarjan sijaan WRCH (tulostaa merkki), WRITES (tulostaa merkkijonon), WRITEN , WRITED , WRITEOCT , WRITEHEX (tulostaa numeroita eri muodoissa), yksi kutsu käytettiin, jossa oli mahdollista lomittaa "vain teksti" lähtöarvoihin. %

Sitä seurannut Bee- kieli vuonna 1969 käytti jo nimeä printf yksinkertaisen muotoisen merkkijonon kanssa (samanlainen kuin BCPL ), määritellen vain yhden kolmesta mahdollisesta tyypistä ja kahdesta numeromuodosta: desimaali ( ), oktaali ( ), merkkijonot ( ) ja merkit ( ), ja ainoa tapa muotoilla tulos näissä funktioissa oli lisätä merkkejä ennen ja jälkeen muuttujan arvon tulosteen. [2]%d%o%s%c

C ja johdannaiset

C-kielen ensimmäisen version ( 1970 ) käyttöönoton jälkeen printf -perheestä on tullut tärkein muototulostustyökalu. Kustannuksia muotomerkkijonon jäsentämisestä kunkin funktiokutsun yhteydessä pidettiin hyväksyttävinä, eikä kirjastoon otettu kullekin tyypille erikseen vaihtoehtoisia kutsuja. Toimintomäärittely sisältyi molempiin olemassa oleviin kielistandardeihin , jotka julkaistiin vuosina 1990 ja 1999 . Vuoden 1999 spesifikaatio sisältää joitain innovaatioita vuoden 1990 spesifikaatiosta.

C++-kieli käyttää standardia C-kirjastoa (vuoden 1990 standardin mukaan), mukaan lukien koko printf -perhe .

Vaihtoehtona C++-standardikirjasto tarjoaa joukon virransyöttö- ja tulosluokkia. Tämän kirjaston lähtökäskyt ovat tyyppiturvallisia eivätkä vaadi muotomerkkijonojen jäsentämistä joka kerta, kun niitä kutsutaan. Monet ohjelmoijat käyttävät kuitenkin edelleen printf -perhettä , koska niiden tulostussekvenssi on yleensä kompaktimpi ja käytetyn muodon olemus on selkeämpi.

Objective-C on melko "ohut" C:n lisäosa, ja siinä olevat ohjelmat voivat käyttää suoraan printf -perheen toimintoja .

Käyttö muilla ohjelmointikielillä

C:n ja sen johdannaisten (C++, Objective-C) lisäksi monet muut ohjelmointikielet käyttävät printf-muotoista merkkijonosyntaksia:

• Perl  - sprintf [3] ;
• Python  - muoto-operaattori % [4] ja funktio str.format ;
• PHP  - funktio printf [5] ;
• Java  - toiminto java.io.PrintStream.printf [6] ;
• Ruby - printf -  funktio [7] ;
• Lua  - funktio string.format [8] ;
• TCL  - funktiomuoto [9] ;
• GNU Octave - printf -  toiminto [10] ;
• Maple - printf -  funktio (sulautettu kieli) [11] ;
• AMPL [12] ;
• Elisp (muotoile merkkijono &rest-objektit) [13] ;
• OCaml - printf -  funktio [14] ;
• Haskell - printf - funktio [15] ;
• Ruoste - makrotulostus! [16] ;
• Pascal - Muotoilutoiminto [17] .
• Go - toiminto fmt.Printf (fmt.Sprintf tulostamiseen merkkijonoon) [18]

Lisäksi useimpiin UNIX-tyyppisiin järjestelmiin sisältyvän printf - apuohjelman ansiosta printf : ää käytetään monissa shell-skripteissä ( sh , bash , csh , zsh jne.).

Seuraajat

Jotkut uudemmat kielet ja ohjelmointiympäristöt käyttävät myös muotomerkkijonopohjaisen tulosteen käsitettä, mutta eri syntaksilla.

Esimerkiksi .Net Core Class Library (FCL) sisältää menetelmäperheen System.String.Format , System.Console.Write ja System.Console.WriteLine , joiden jotkin ylikuormitukset tulostavat tietonsa muotomerkkijonon mukaan. Koska täydelliset tiedot objektityypeistä ovat saatavilla .Net-ajoaikana, näitä tietoja ei tarvitse välittää muotomerkkijonossa.

Perhefunktion nimeäminen

Kaikkien funktioiden nimessä on kanta printf . Etuliitteet ennen funktion nimeä tarkoittavat:

• v ( vprintf , vsnprintf jne.) - muuttuvan parametrimäärän sijaan funktio ottaa listan argumenteista va list .
• f ( fprintf , vfprintf ) - tulostaa tuloksen funktioparametrin kautta kulkevaan virtaan vakiotulosteen sijaan.
• s ( sprintf , snprintf , vsprintf , vsnprintf ) kirjoittaa tuloksen merkkijonoon ( puskuriin muistissa), ei streamiin.
• n ( snprintf , vsnprintf ) - parametrin läsnäolo, joka rajoittaa tuloksen kirjoittamisen merkkien enimmäismäärää (käytetään vain s -etuliitteellä ). Maplessa nprintf- funktio on samanlainen kuin sprintf , mutta palauttaa nimen tekstimerkkijonon sijaan.
• w , ennen muita etuliitteitä ( wsprintf , wvsprintf , wnsprintf , wvnsprintf ) on etuliite, jota Microsoft käyttää sprintf -funktioperheen toteutuksissa Windows - käyttöjärjestelmissä .
• w , muiden etuliitteiden ( fwprintf , swprintf , wprintf ) jälkeen - funktio käyttää "leveitä" merkkijonoja ( wchar_t ) tavallisten merkkijonojen sijaan. (Samaan aikaan swprintf -funktiolla ei ole "n"-etuliitettä, vaikka se ottaa parametrin, joka rajoittaa tuloksena olevan merkkijonon kokoa).
• a ( asprintf , vasprintf ) ovat GNU - laajennuksia ; toimii samalla tavalla kuin sprintf/vsprintf, mutta varaa tarpeeksi muistia mallocilla muotoiltua merkkijonoa varten. Merkkijonoon osoittavan osoittimen sijaan nämä toiminnot vievät osoittimen merkkijonoon; kutsutoiminto vapauttaa muistin.

Yleiset käytännöt

Kaikki funktiot ottavat muotomerkkijonon yhdeksi parametriksi ( format ) ( merkkijonon syntaksin kuvaus alla). Palauttaa kirjoitettujen (tulostettujen) merkkien lukumäärän, ei sisällä tyhjää merkkiä merkin lopussa . Muotoillun tulosteen dataa sisältävien argumenttien määrän on oltava vähintään yhtä monta kuin muotomerkkijonossa on mainittu. "Lisäargumentit" jätetään huomiotta.

Perhefunktiot n ( snprintf , vsnprintf ) palauttavat niiden merkkien määrän, joka tulostettaisiin, jos parametri n (rajoittaa tulostettavien merkkien määrää) olisi riittävän suuri. Yksitavuisissa koodauksissa palautusarvo vastaa haluttua merkkijonon pituutta (ei sisällä tyhjää merkkiä lopussa).

S -perheen funktiot ( sprintf , snprintf , vsprintf , vsnprintf ) ottavat ensimmäiseksi parametrikseen osoittimen muistialueelle, johon tuloksena oleva merkkijono kirjoitetaan. Toiminnot, joilla ei ole rajoitusta kirjoitettavien merkkien määrälle, ovat vaarallisia toimintoja, koska ne voivat johtaa puskurin ylivuotovirheeseen , jos tulostemerkkijono on suurempi kuin tulostettavaksi varatun muistin koko.

F -perhefunktiot kirjoittavat merkkijonon mihin tahansa avoimeen virtaan ( virtaparametri ), erityisesti standardilähtövirtoihin ( stdout , stderr ). fprintf(stdout, format, …)vastaa printf(format, …).

V -perhefunktiot eivät ota argumentteja muuttuvana lukumääränä argumentteja (kuten kaikki muut printf-funktiot), vaan listana va list . Tässä tapauksessa, kun toimintoa kutsutaan, va end -makroa ei suoriteta.

W (ensimmäinen merkki ) -perhefunktiot ovat Microsoftin rajoitettu toteutus s -funktioperheestä : wsprintf , wnsprintf , wvsprintf , wvnsprintf . Nämä toiminnot on toteutettu dynaamisissa kirjastoissa user32.dll ja shlwapi.dll ( n funktiota). Ne eivät tue liukulukutulostusta, ja wnsprintf ja wvnsprintf tukevat vain vasemmalle tasattua tekstiä.

W -perheen toiminnot ( wprintf , swprintf ) toteuttavat tuen monitavuisille koodauksille, kaikki tämän perheen toiminnot toimivat osoittimilla monitavuisiin merkkijonoihin ( wchar_t ).

A -perheen funktiot ( asprintf , vasprintf ) varaavat muistia lähtömerkkijonolle malloc -funktiolla , muisti vapautetaan kutsuproseduurissa, jos funktion suorittamisessa tapahtuu virhe, muistia ei varata.

Toimintojen kuvaus

Parametrien nimet

• muoto  - muotomerkkijono (muoto on kuvattu alla)
• stream  - tiedostovirta ulostuloon
• s  - merkkijono funktion tuloksen sijoittamiseen
• n  on muuttuja, joka sisältää suurimman sallitun merkkimäärän merkkijonolle s
• ap  - tulostettavien arvojen luettelo
• strp  - osoitin merkkijonoon funktion tulosten sijoittamiseksi

Toimintojen kuvaus

• int printf( const char *format, ... ); Muotoiltu merkkijonolähtö stdout-muotoon
• int fprintf( FILE *stream, const char *format, ... ); Muotoillun merkkijonon tulostaminen streamiin
• int sprintf( char *s, const char *format, ... ); Kirjoita muotoiltu merkkijono merkkijonoon ilman merkkijonon kokoa
• int snprintf( char *s, size_t n, const char *format, ... ); Muotoillun merkkijonon kirjoittaminen merkkijonoon, jolla on merkkijonon kokorajoitus
• int vprintf( const char *format, va_list ap ); Muotoiltu merkkijonotulostus vakiolähtöön, lähtöarvot välitetään funktiolle lista va -listana
• int vfprintf( FILE *stream, const char *format, va_list ap ); Kun kirjoitetaan muotoiltu merkkijono streamiin, tulosteen arvot välitetään funktiolle listana va listana
• int vsprintf( char *s, const char *format, va_list ap ); Muotoillun merkkijonon kirjoittaminen merkkijonoon ilman kokorajoitusta; lähtöarvot välitetään funktiolle lista va -listana
• int vsnprintf( char *s, size_t n, const char *format, va_list ap ); Kirjoita muotoiltu merkkijono merkkijonoon, jonka tulostettavien merkkien määrä on rajoitettu. Tulostusarvot välitetään funktiolle listana
• int fwprintf(FILE *stream, const wchar_t *format, ... ); Muotoillun monitavuisen merkkijonon kirjoittaminen tiedostoon
• int swprintf(wchar_t *ws, size_t n, const wchar_t *format, ... ); Muotoillun monitavuisen merkkijonon kirjoittaminen muistialueelle ( Huomautus: vaikka nimessä ei ole kirjainta n , tämä funktio hyväksyy parametrin, joka rajoittaa tulostemerkkijonon enimmäiskokoa ).
• int wprintf(const wchar_t *format, ... ); Lähetetään monitavuinen muotoiltu merkkijono päätteelle
• int wsprintf( LPTSTR s, LPCTSTR format, ... ); Sprintf - toiminnon toteutus Windows - käyttöjärjestelmässä . Toisin kuin sprintf, se ei tue liukulukuarvojen tulostamista, osoittimien tulostamista, tukee lisäksi monitavuisten merkkijonojen käsittelyä funktion yksitavuisessa versiossa), ei tue '+'-lippua.
• int wnsprintf( LPTSTR s, int n, LPCTSTR format, ... ); snprintf - toiminnon toteutus Windows - käyttöjärjestelmässä . Ei tue liukulukuarvojen ja osoittimien tulostamista, tukee vain vasemmalle tasattua lippua.
• int wvsprintf( LPTSTR s, LPCTSTR format, va_list ap );
• int wvnsprintf( LPTSTR s, int n, LPCTSTR format, va_list ap );
• int asprintf(char **strp, const char *format, ... ); funktio kirjoittaa tuloksen merkkijonoon, jolle on varattu muisti mallocilla
• int vasprintf(char **strp, const char *format, va_list ap); funktio kirjoittaa tuloksen merkkijonoon, jolle on varattu muisti mallocilla , tulosarvot välitetään funktiolle listana va list

Paluuarvo: negatiivinen arvo — virhemerkki; onnistuessaan funktiot palauttavat kirjoitettujen/tulostettujen tavujen määrän (jättämättä tyhjän tavun lopussa), snprintf- funktio tulostaa tavumäärän, joka kirjoitettaisiin, jos n olisi tarpeeksi suuri.

Kutsuttaessa snprintf : ää n voi olla nolla (jolloin s voi olla nollaosoitin ), jolloin kirjoitusta ei tehdä, funktio palauttaa vain oikean palautusarvon.

Muotoile merkkijonon syntaksi

C:ssä ja C++:ssa muotomerkkijono on nollapääteinen merkkijono. Kaikki merkit paitsi muotomäärittäjät kopioidaan tuloksena olevaan merkkijonoon muuttumattomina. Muotomääritteen alun vakiomerkki on merkki %( Percent sign ), itse merkin näyttämiseksi %käytetään sen tuplausta %%.

Muotomääritteen rakenne

Muotomääritys näyttää tältä:

% [ liput ][ leveys ][ . tarkkuus [ koko ] tyyppi

Vaadittavat komponentit ovat muotomääritteen aloitusmerkki ( %) ja tyyppi .

Liput

Merkki	Merkitse nimi	Merkitys	Tämän merkin puuttuessa	Merkintä
-	miinus	tuloste on tasattu vasemmalle kentän vähimmäisleveyden sisällä	oikealla
+	Plussa	määritä aina merkki (plus tai miinus) näytettävälle desimaalilukuarvolle	vain negatiivisille luvuille
	tilaa	laita välilyönti ennen tulosta, jos arvon ensimmäinen merkki ei ole merkki	Tulos voi alkaa numerolla.	+ -merkki on etusijalla välilyöntiin nähden . Käytetään vain etumerkityille desimaaliarvoille.
#	ristikko	arvotuotannon "vaihtoehtoinen muoto".		Kun tulostetaan lukuja heksadesimaali- tai oktaalimuodossa, numeroa edeltää muotoominaisuus (0x tai 0, vastaavasti).
0	nolla	täytä kenttä symbolilla Escape-sekvenssin leveyskentässä määritettyyn leveyteen0	tyyny välilyönnillä	Käytetään tyypeille d , i , o , u , x , X , a , A , e , E , f , F , g , G . Tyypeille d , i , o , u , x , X , jos tarkkuus on määritetty, tämä lippu jätetään huomiotta. Muille tyypeille käyttäytyminen on määrittelemätön. Jos miinus '-' -lippu on määritetty, sekin ohitetaan.

Leveyden muokkaus

Leveys (desimaali tai tähtimerkki ) määrittää kentän vähimmäisleveyden (mukaan lukien numeroiden etumerkki). Jos arvon esitys on suurempi kuin kentän leveys, merkintä on kentän ulkopuolella (esimerkiksi %2i arvolle 100 antaa kolmen merkin kentän arvon), jos arvon esitys on pienempi kuin määritetty luku, sitten se täytetään (oletusarvoisesti) välilyönneillä vasemmalla, käyttäytyminen voi vaihdella muiden asetettujen lippujen mukaan. Jos leveydeksi määritetään tähti, kentän leveys määritetään argumenttiluettelossa ennen tulosarvoa ( printf( "%0*x", 8, 15 );näyttää esimerkiksi tekstin 0000000f). Jos negatiivinen leveysmuuttaja on määritetty tällä tavalla, lippua - pidetään asetettuna ja leveysmuuttajan arvoksi asetetaan absoluuttinen.

Tarkkuusmuuttaja

• ilmaisee merkkien vähimmäismäärän, jonka tulee esiintyä käsiteltäessä tyyppejä d , i , o , u , x , X ;
• ilmaisee merkkien vähimmäismäärän, jonka on oltava desimaalipilkun (pisteen) jälkeen, kun käsitellään tyyppejä a , A , e , E , f , F ;
• merkitsevien merkkien enimmäismäärä tyypeille g ja G ;
• tyypin s tulostettavien merkkien enimmäismäärä ;

Tarkkuus määritetään pisteenä, jota seuraa desimaaliluku tai tähti ( * ). Jos numeroa tai tähteä ei ole (vain piste on olemassa), luvun oletetaan olevan nolla. Pistettä käytetään osoittamaan tarkkuutta, vaikka pilkku näytetään liukulukuja tulostettaessa.

Jos pisteen jälkeen on määritetty tähtimerkki, muotomerkkijonoa käsiteltäessä kentän arvo luetaan argumenttiluettelosta. (Samaan aikaan, jos tähtimerkki on sekä leveys- että tarkkuuskentässä, ensin ilmoitetaan leveys, sitten tarkkuus ja vasta sitten tulosteen arvo). Se printf( "%0*.*f", 8, 4, 2.5 );näyttää esimerkiksi tekstin 002.5000. Jos negatiivinen tarkkuusmuunnin määritetään tällä tavalla, tarkkuusmuuttajaa ei ole. [19]

Kokomuuttaja

Koko - kentässä voit määrittää funktiolle välitettävien tietojen koon. Tämän kentän tarve selittyy C-kielen funktiolle mielivaltaisen määrän parametrien välittämisen erikoisuuksilla: funktio ei voi "itsenäisesti" määrittää siirrettävän tiedon tyyppiä ja kokoa, joten tietoa parametrien tyypeistä ja niiden koosta. tarkka koko on annettava erikseen.

Kun otetaan huomioon kokomäärittelyjen vaikutus kokonaislukutietojen muotoiluun, on huomattava, että C- ja C++-kielissä on ketju etumerkittyjen ja etumerkittömien kokonaislukutyyppien pareja, jotka kokojen ei-laskevassa järjestyksessä ovat järjestetty seuraavasti:

allekirjoitettu tyyppi	Allekirjoittamaton tyyppi
allekirjoitettu char	allekirjoittamaton merkki
allekirjoitettu lyhyt ( lyhyt )	unsigned short int ( unsigned short )
allekirjoitettu int ( int )	allekirjoittamaton int ( unsigned )
allekirjoitettu pitkä int ( pitkä )	allekirjoittamaton pitkä int ( unsigned long )
pitkä pitkä int ( pitkä pitkä )	allekirjoittamaton pitkä pitkä int ( allekirjoittamaton pitkä pitkä )

Tyyppien tarkkaa kokoa ei tunneta, lukuun ottamatta etumerkittyjä ja etumerkittömiä merkkityyppejä .

Parilliset allekirjoitetut ja allekirjoittamattomat tyypit ovat samankokoisia, ja molemmissa tyypeissä esitettävillä arvoilla on sama esitystapa.

Merkkityyppi on samankokoinen kuin etumerkillinen merkki ja etumerkitön merkki , ja se jakaa joukon edustavia arvoja yhden näistä tyypeistä. Lisäksi oletetaan, että char  on toinen nimi jollekin näistä tyypeistä; tällainen oletus on hyväksyttävä tässä tarkastelussa.

Lisäksi C:llä on _Bool- tyyppi , kun taas C++:lla on bool -tyyppi .

Kun funktiolle välitetään argumentteja, jotka eivät vastaa funktion prototyypin muodollisia parametreja (jotka ovat kaikki lähtöarvoja sisältäviä argumentteja), nämä argumentit käyvät läpi standardin ylennyksiä , nimittäin:

• float argumentit heitetään kaksinkertaiseksi ;
• tyyppien unsigned char , unsigned short , signed char ja short argumentit lähetetään johonkin seuraavista tyypeistä:
  • int , jos tämä tyyppi pystyy edustamaan kaikkia alkuperäisen tyypin arvoja, tai
  • allekirjoittamaton muuten;
• _Bool- tai bool - tyypin argumentit heitetään tyyppiin int .

Näin ollen printf-funktiot eivät voi ottaa argumentteja, joiden tyyppi on float , _Bool tai bool , tai kokonaislukutyyppejä, jotka ovat pienempiä kuin int tai unsigned .

Käytettyjen kokomääritteiden joukko riippuu tyyppimäärityksestä (katso alla).

määrittäjä	%d, %i, %o, %u, %x,%X	%n	Merkintä
puuttuu	int tai allekirjoittamaton int	osoitin int
l	long int tai unsigned long int	osoitin pitkä int
hh	Argumentti on tyyppiä int tai unsigned int , mutta se on pakotettu kirjoittamaan signed char tai unsigned char , vastaavasti	osoitin signed char	muodollisesti olemassa C-kielessä vuoden 1999 standardista lähtien ja C++:ssa 2011-standardista lähtien.
h	Argumentti on tyyppiä int tai unsigned int , mutta se on pakotettu kirjoittamaan short int tai unsigned short int , vastaavasti	osoitin lyhyt int
ll	pitkä pitkä int tai allekirjoittamaton pitkä pitkä int	osoitin pitkä pitkä int
j	intmax_t tai uintmax_t	osoitin kohtaan intmax_t
z	size_t (tai kokoa vastaava signeerattu tyyppi)	osoitin etumerkittuun tyyppiin , joka vastaa kokoa koko_t
t	ptrdiff_t (tai vastaava allekirjoittamaton tyyppi)	osoitin kohtaan ptrdiff_t
L	__int64 tai allekirjoittamaton __int64	osoitin kohtaan __int64	Borland Builder 6:lle (määrittäjä llodottaa 32-bittistä numeroa)

Tekniset tiedot hja hhniitä käytetään kompensoimaan vakiotyyppisiä ylennyksiä, kun siirrytään allekirjoitetuista tyypeistä allekirjoittamattomiin tai päinvastoin.

Tarkastellaan esimerkiksi C-toteutusta, jossa char -tyyppi on etumerkitty ja sen koko on 8 bittiä, int -tyypin koko on 32 bittiä ja käytetään lisätapaa negatiivisten kokonaislukujen koodaamiseen.

char c = 255 ; printf ( "%X" , c );

Tällainen kutsu tuottaa tulosteen FFFFFFFF, joka ei ehkä ole sitä, mitä ohjelmoija odotti. Itse asiassa c :n arvo on (char)(-1) , ja tyypin edistämisen jälkeen se on -1 . Muotoa %Xkäytettäessä annettu arvo tulkitaan etumerkittömäksi eli 0xFFFFFFFF .

char c = 255 ; printf ( "%X" , ( signed char ) c ); char c = 255 ; printf ( "%hhX" , c );

Näillä kahdella kutsulla on sama vaikutus ja ne tuottavat tulosteen FF. Ensimmäinen vaihtoehto mahdollistaa merkkien kertomisen välttämisen tyyppiä mainostettaessa, toinen kompensoi sen jo printf -funktion "sisällä" .

määrittäjä	%a, %A, %e, %E, %f, %F, %g,%G
puuttuu	kaksinkertainen
L	pitkä tupla

määrittäjä	%c	%s
puuttuu	Argumentti on tyyppiä int tai unsigned int , mutta se on pakotettu kirjoittamaan char	char*
l	Argumentti on tyyppiä wint_t , mutta se on pakotettu kirjoittamaan wchar_t	wchar_t*

Tyyppimäärittäjä

Tyyppi ilmaisee arvon tyypin (C-ohjelmointikielen näkökulmasta katsottuna) lisäksi myös lähtöarvon erityistä esitystä (esim. numerot voidaan näyttää desimaali- tai heksadesimaalimuodossa). Kirjoitettu yhtenä hahmona. Toisin kuin muut kentät, se on pakollinen. Yhden koodinvaihtomerkkijonon suurin tuettu tulostekoko on standardien mukaan vähintään 4095 merkkiä. käytännössä useimmat kääntäjät tukevat huomattavasti suurempia tietomääriä.

Tyyppiarvot:

• d , i  — etumerkillinen desimaaliluku, oletustyyppi on int . Oletusarvoisesti se kirjoitetaan oikealla tasauksella, etumerkki kirjoitetaan vain negatiivisille luvuille. Toisin kuin scanf -perheen funktiot, printf -perheen funktioille %d- ja %i - määritykset ovat täysin synonyymejä;
• o  — etumerkitön oktaaliluku, oletustyyppi on unsigned int ;
• u  on etumerkitön desimaaliluku, oletustyyppi on unsigned int ;
• x ja X  ovat etumerkittömiä heksadesimaalilukuja, x käyttää pieniä kirjaimia (abcdef), X käyttää suuria kirjaimia (ABCDEF), oletustyyppi on unsigned int ;
• f ja F  ovat liukulukuja, oletustyyppi on double . Oletusarvoisesti ne tulostetaan tarkkuudella 6, jos moduuliluku on pienempi kuin yksi, kirjoitetaan desimaalipilkun eteen 0. ±∞ :n arvot esitetään muodossa [-]inf tai [-]infinity (alustasta riippuen); Nan :n arvo esitetään muodossa [-]nan tai [-]nan (mikä tahansa teksti alla) . F :tä käyttämällä tulostetaan määritetyt arvot isoin kirjaimin ( [-]INF , [-]INFINITY , NAN ).
• e ja E  ovat liukulukuja eksponentiaalisessa merkinnässä (muodossa 1.1e+44), oletustyyppi on double . e tulostaa merkin "e" pienillä kirjaimilla, E  - isoilla kirjaimilla (3.14E+0);
• g ja G  ovat liukuluku, oletustyyppi on double . Esitysmuoto riippuu suuren ( f tai e ) arvosta. Muoto eroaa hieman liukulukusta siinä, että desimaalipilkun oikealla puolella olevia etunollia ei tulosteta. Puolipisteosaa ei myöskään näytetä, jos luku on kokonaisluku;
• a ja A (alkaen C-kielistandardeista vuodelta 1999 ja C++ vuodesta 2011) — liukulukuluku heksadesimaalimuodossa, oletustyyppi on double ;
• c  — Symbolin tulostaminen ohitettua argumenttia vastaavalla koodilla, oletustyyppi on int ;
• s  - merkkijonon tulos nollapäätteisellä tavulla; jos pituusmuuttaja on l , tulostetaan merkkijono wchar_t* . Windowsissa tyypin s arvot riippuvat käytettyjen toimintojen tyypistä. Jos käytetään printffunktioperhettä, s tarkoittaa merkkijonoa char* . Jos käytetään wprintffunktioperhettä, s tarkoittaa merkkijonoa wchar_t* .
• S  on sama kuin s pituusmuuntimella l ; Windowsissa tyypin S arvo riippuu käytettyjen funktioiden tyypistä. Jos käytetään printffunktioperhettä, S tarkoittaa merkkijonoa wchar_t* . Jos käytetään wprintffunktioperhettä, S tarkoittaa merkkijonoa char* .
• p - osoittimen  ulostulo , ulkonäkö voi vaihdella merkittävästi kääntäjän ja alustan sisäisen esityksen mukaan (esimerkiksi 16-bittinen MS-DOS-alusta käyttää lomakkeen merkintää FFEC:1003, 32-bittinen alusta, jossa on litteä osoite, käyttää osoitetta lomakkeesta 00FA0030);
• n - tietue osoittimelta, välitetty argumenttina, n: n  sisältävän komentojonon esiintymishetkellä kirjoitettujen merkkien määrä ;
• %  - merkki näyttää prosenttimerkin (%), jota käytetään mahdollistamaan prosenttimerkkien tulostaminen printf-merkkijonossa, jota käytetään aina muodossa %%.

Liukulukujen tulos

Nykyisestä maa -asennosta riippuen sekä pilkkua että pistettä (ja mahdollisesti toista symbolia) voidaan käyttää liukulukujen näyttämisessä. Printf : n käyttäytyminen suhteessa luvun murto- ja kokonaislukuosan erottavaan merkkiin määräytyy käytössä olevan kielen (tarkemmin sanottuna muuttujan LC NUMERIC ) mukaan. [kaksikymmentä]

Erikoismakrot laajennetun joukon kokonaislukutietotyyppien aliaksia

Toinen C-standardi (1999) tarjoaa laajennetun joukon aliaksia kokonaislukutietotyypeille int N _t , uint N _t , int_least N _t , uint_least N _t , int_fast N _t , uint_fast N _t (missä N vaadittu bittisyvyys), intptr_t , uintptr_t , intmax_t , uintmax_t .

Jokainen näistä tyypeistä saattaa vastata mitä tahansa vakiomuotoista sisäänrakennettua kokonaislukutyyppiä. Muodollisesti ottaen kannettavaa koodia kirjoittaessaan ohjelmoija ei tiedä etukäteen, mitä standardia tai laajennettua kokomääritystä hänen tulisi soveltaa.

int64_t x = 100000000000 ; int leveys = 20 ; printf ( "%0*lli" , leveys , x ); Väärin, koska int64_t ei välttämättä ole sama kuin long long int .

Jotta näiden tyyppien objektien tai lausekkeiden arvot voitaisiin päätellä kannettavalla ja kätevällä tavalla, toteutus määrittelee kullekin näistä tyypeistä joukon makroja, joiden arvot ovat merkkijonoja, jotka yhdistävät koko- ja tyyppimääritykset.

Makrojen nimet ovat seuraavat:

Pari allekirjoitettua ja allekirjoittamatonta tyyppiä	Makron nimi
int N_t ja uint N_t _ _	PRITN
int_least N _t ja uint_least N _t	PRITLEASTN
int_fastN_t ja uint_fastN_t _ _ _ _	PRITFASTN
intmax_t ja uintmax_t	PRITMAX
intptr_t ja uintptr_t	PRITPTR

Tässä T on yksi seuraavista tyyppimäärityksistä: d, i, u, o, x, X.

int64_t x = 100000000000 ; int leveys = 20 ; printf ( "%0*" PRIi64 , leveys , x ); Oikea tapa tulostaa int64_t -tyyppinen arvo C-kielellä.

Saatat huomata, että tyypeillä intmax_t ja uintmax_t on vakiokokomääritys j, joten makro on todennäköisesti aina määritelty muodossa . PRITMAX"jT"

XSI-laajennukset Single Unix-standardissa

Single UNIX -standardin (käytännöllisesti katsoen POSIX - standardia vastaavan ) mukaan seuraavat lisäykset printf:ään on määritelty suhteessa ISO C: hen XSI (X/Open System Interface) -laajennuksen alla:

• Mahdollisuus tulostaa mielivaltainen parametri numerolla lisätään (ilmaistaan n$​​välittömästi ohjausjakson alun merkin jälkeen, esimerkiksi printf("%1$d:%2$.*3$d:%4$.*3$d\n", hour, min, precision, sec);).
• Lisätty lippu "'" (yksi lainausmerkki), joka tyypeille d , i , o , u määrää erilliset luokat vastaavalla merkillä.
• tyyppi C vastaa lc ISO C:tä (tyyppi wint_t ).
• tyyppi S , joka vastaa ls ISO C:tä (merkkijonolähtö kuten wchar_t* )
• Lisätty virhekoodit EILSEQ, EINVAL, ENOMEM, EOVERFLOW.

Epätyypilliset laajennukset

GNU C Library

GNU C -kirjasto ( libc ) lisää seuraavat laajennukset:

• tyyppi m tulostaa globaalin muuttujan errno arvon (viimeisen funktion virhekoodi).
• tyyppi C vastaa lc :tä .
• lippua ' (yksi lainausmerkki) käytetään luokkien erottamiseen numeroita tulostettaessa. Erotusmuoto riippuu LC_NUMERIC :sta
• q : n koko ilmaisee tyypin long long int (järjestelmissä joissa long long int ei ole tuettu tämä on sama kuin long int
• koko Z on alias z :lle , otettiin käyttöön libc:ssä ennen C99-standardin tuloa , eikä sitä suositella käytettäväksi uudessa koodissa.

Omien tyyppien rekisteröinti

GNU libc tukee mukautetun tyypin rekisteröintiä, jolloin ohjelmoija voi määrittää tulosmuodon omille tietorakenteilleen. Rekisteröi uusi tyyppi funktiolla
int register_printf_function (int type, printf_function handler-function, printf_arginfo_function arginfo-function), jossa:

• type  — tyypin kirjain (jos tyyppi = 'Y', puhelu näyttää tältä "%Y");
• Käsittelijä-funktio  - osoitin funktioon, jota printf-funktiot kutsuvat, jos tyypissä määritetty tyyppi löytyy muotomerkkijonosta ;
• arginfo-funktio  on osoitin funktioon, jota parse_printf_format -funktio kutsuu .

Uusien tyyppien määrittämisen lisäksi rekisteröinti mahdollistaa olemassa olevien tyyppien (kuten s , i ) uudelleenmäärittelyn.

Microsoft Visual C

Microsoft Visual Studio C/C++-ohjelmointikielille printf-määrityksen (ja muiden perhetoimintojen) muodossa tarjoaa seuraavat laajennukset:

• laatikon koko:

kentän arvo	tyyppi
I32	allekirjoitettu __int32 , allekirjoittamaton __int32
I64	allekirjoitettu __int64 , allekirjoittamaton __int64
minä	ptrdiff_t , koko_t
w	vastaa l merkkijonoille ja merkeille

vaahtera

Maple matematiikkaympäristössä on myös printf-funktio, jossa on seuraavat ominaisuudet:

Muotoilu

1. • %a, %A: Maple-objekti palautetaan tekstimuodossa, tämä toimii kaikille objekteille (esim. matriisit, funktiot, moduulit jne.). Pienet kirjaimet ohjeistavat ympäröimään merkit (nimet) selkämerkeillä, jotka tulee ympäröidä painikkeilla printf.
   • %q, %Q: sama kuin %a/%A, mutta ei vain yhtä argumenttia käsitellä, vaan kaikkea alkaen siitä, joka vastaa muotoilulippua. Siten %Q/%q-lippu voi esiintyä muotomerkkijonossa vain viimeisenä.
   • %m: Muotoile objekti sen sisäisen Maple-esityksen mukaan. Käytännössä käytetään muuttujien kirjoittamiseen tiedostoon.

Esimerkki:

> printf("%a =%A", `+`, `+`); `+` = + > printf("%a =%m", `+`, `+`); `+` = I"+f*6"F$6#%(builtinGF$"$Q"F$F$F$F"%*suojattuG Johtopäätös

Maplen fprintf-funktio ottaa joko tiedostokuvaajan (fopen palauttaa) tai tiedostonimen ensimmäisenä argumenttina. Jälkimmäisessä tapauksessa nimen tulee olla "symboli"-tyyppinen, jos tiedoston nimi sisältää pisteitä, niin se on suljettava backticksillä tai muunnettava muunnostoiminnolla (tiedoston_nimi, symboli).

Haavoittuvuudet

Printf -perheen funktiot ottavat argumenttiluettelon ja niiden koon erillisenä parametrina (muotomerkkijonossa). Muotomerkkijonon ja hyväksyttyjen argumenttien välinen ristiriita voi johtaa arvaamattomaan toimintaan, pinon vioittumiseen, mielivaltaiseen koodin suorittamiseen ja dynaamisten muistialueiden tuhoutumiseen. Monia perheen toimintoja kutsutaan "unsafeiksi" ( englanniksi  unsafe ), koska niillä ei ole edes teoreettista kykyä suojautua virheellisiltä tiedoilta.

Myöskään s -perheen funktioilla (ilman n :ää , kuten sprintf , vsprintf ) ei ole rajoituksia kirjoitetun merkkijonon enimmäiskoon suhteen ja ne voivat johtaa puskurin ylivuotovirheeseen (kun dataa kirjoitetaan varatun muistialueen ulkopuolelle).

Käyttäytyminen, kun muotomerkkijono ja välitetyt argumentit eivät täsmää

Osana kutsumiskäytäntöä pinoncdecl puhdistaminen suoritetaan kutsutoiminnon avulla. Kun printf :ää kutsutaan , argumentit (tai osoittimet niihin) sijoitetaan siihen järjestykseen, jossa ne kirjoitetaan (vasemmalta oikealle). Kun muotomerkkijonoa käsitellään, printf -funktio lukee argumentit pinosta. Seuraavat tilanteet ovat mahdollisia:

• argumenttien määrä ja tyyppi vastaavat muotomerkkijonossa määritettyjä (normaali funktiotoiminto)
• funktiolle välitettiin enemmän argumentteja kuin muotomerkkijonossa on määritetty (ylimääräiset argumentit)
• Funktiolle välitettiin vähemmän argumentteja kuin muotomerkkijono vaatii (riittämättömästi argumentteja)
• Väärän kokoiset argumentit välitettiin funktiolle
• Oikean kokoiset mutta väärän tyyppiset argumentit välitettiin funktiolle

C-kielen määritykset kuvaavat vain kaksi tilannetta (normaali toiminta ja lisäargumentit). Kaikki muut tilanteet ovat virheellisiä ja johtavat määrittelemättömään ohjelman toimintaan (todellisuudessa mikä johtaa mielivaltaisiin tuloksiin aina suunnittelemattomien koodiosien suorittamiseen).

Liian monta argumenttia

Kun välitetään liikaa argumentteja, printf -funktio lukee argumentit, jotka tarvitaan muotoilevan merkkijonon käsittelemiseksi oikein ja palaa kutsuvaan funktioon. Kutsuva funktio tyhjentää spesifikaation mukaisesti pinon kutsutulle funktiolle välitetyistä parametreista. Tässä tapauksessa ylimääräisiä parametreja ei yksinkertaisesti käytetä, ja ohjelma jatkuu ilman muutoksia.

Ei tarpeeksi argumentteja

Jos pinossa on vähemmän argumentteja kutsuttaessa printf : ää kuin tarvitaan muotomerkkijonon käsittelyyn, puuttuvat argumentit luetaan pinosta huolimatta siitä, että pinossa on mielivaltaisia ​​tietoja (ei ole merkitystä printf :n työn kannalta ) . Jos tietojenkäsittely oli ”onnistui” (eli se ei lopettanut ohjelmaa, jumittunut tai kirjoittanut pinoon), kutsufunktioon palaamisen jälkeen pinoosoittimen arvo palautetaan alkuperäiseen arvoonsa, ja ohjelma jatkuu.

Kun käsitellään "ylimääräisiä" pinoarvoja, seuraavat tilanteet ovat mahdollisia:

• Tulosteen "ylimääräisen" parametrin (numero, osoitin, symboli jne.) onnistunut lukeminen - pinosta luettu "melkein satunnainen" arvo sijoitetaan tulostuloksiin. Tämä ei aiheuta vaaraa ohjelman toiminnalle, mutta voi johtaa joidenkin tietojen vaarantumiseen (pinoarvojen tulostus, joita hyökkääjä voi käyttää analysoidakseen ohjelman toimintaa ja päästäkseen käsiksi ohjelman sisäisiin/yksityisiin tietoihin).
• Virhe luettaessa arvoa pinosta (esimerkiksi käytettävissä olevien pinoarvojen tyhjentämisen tai "olemattomien" muistisivujen käytön seurauksena) - tällainen virhe todennäköisimmin aiheuttaa ohjelman kaatumisen.
• Parametriin osoittavan osoittimen lukeminen. Merkkijonot välitetään osoittimella, kun pinosta luetaan "mielivaltaista" tietoa, luettua (melkein satunnaista) arvoa käytetään osoittimena satunnaiselle muistialueelle. Ohjelman käyttäytyminen tässä tapauksessa on määrittelemätön ja riippuu tämän muistialueen sisällöstä.
• Parametrin kirjoittaminen osoittimella ( %n) - tässä tapauksessa käyttäytyminen on samanlaista kuin lukeminen, mutta sitä monimutkaistavat mielivaltaiseen muistisoluun kirjoittamisen mahdolliset sivuvaikutukset .

Argumenttityyppi ei täsmää

Muodollisesti mikä tahansa ristiriita argumentin tyypin ja odotuksen välillä aiheuttaa ohjelman määrittelemättömän käyttäytymisen. Käytännössä on useita tapauksia, jotka ovat erityisen mielenkiintoisia ohjelmointikäytännön kannalta:

• Argumentti on samaa tyyppiä kuin odotettiin, mutta eri kokoinen.
• Argumentti on samankokoinen kuin odotettiin, mutta erityyppinen.

Muut tapaukset johtavat pääsääntöisesti ilmeisen virheelliseen käyttäytymiseen ja ovat helposti havaittavissa.

Kokonaisluvun tai liukulukuargumentin koko ei täsmää

Kokonaislukuargumentille (kokonaislukumuotomäärityksellä) seuraavat tilanteet ovat mahdollisia:

• Odotettua suurempien parametrien välittäminen (pienen lukeminen suuremmasta). Tässä tapauksessa, riippuen hyväksytystä tavujärjestyksestä ja pinon kasvusuunnasta, näytettävä arvo voi joko osua yhteen argumentin arvon kanssa tai osoittautua siihen liittymättömäksi.
• Odotettua pienempien parametrien välittäminen (suuremman lukeminen pienemmästä). Tässä tapauksessa tilanne on mahdollinen, kun luetaan pinoalueet, jotka ylittävät ohitettujen argumenttien rajat. Funktion käyttäytyminen tässä tapauksessa on samanlainen kuin käyttäytyminen tilanteessa, jossa parametreja ei ole. Yleensä lähtöarvo ei vastaa odotettua arvoa.

Todelliselle argumentille (todellisella muotomäärityksellä) lähtöarvo ei yleensä vastaa välitettyä arvoa, jos koko ei täsmää.

Yleensä jos jonkin argumentin koko on väärä, kaikkien myöhempien argumenttien oikea käsittely tulee mahdottomaksi, koska argumenttien osoittimeen tulee virhe. Tätä vaikutusta voidaan kuitenkin kompensoida kohdistamalla arvot pinossa.

Pinon arvojen tasaaminen

Monilla alustoilla on kokonaislukujen ja/tai todellisten arvojen kohdistussäännöt, jotka edellyttävät (tai suosittelevat) niiden sijoittamista osoitteisiin, jotka ovat niiden koon kerrannaisina. Nämä säännöt koskevat myös funktion argumenttien välittämistä pinossa. Tässä tapauksessa useita odotettujen ja todellisten parametrien tyypeissä olevia epäsuhtauksia voi jäädä huomaamatta, mikä luo illuusion oikeasta ohjelmasta.

uint32_t a = 1 ; uint64_t b = 2 , c = 3 ; printf ( "%" PRId64 "%" PRId64 "%" PRId64 , b , a , c ); Tässä esimerkissä todellisella atyyppiparametrilla on uint32_tvirheellinen muotomäärittely, joka liittyy %"PRId64"tyyppiin uint64_t. Kuitenkin joissakin alustoissa, joissa on 32-bittinen tyyppi int, virhe voi jäädä huomaamatta hyväksytystä tavujärjestyksestä ja pinon kasvusuunnasta riippuen. Varsinaiset parametrit bja ckohdistetaan osoitteeseen, joka on niiden koon monikerta (kaksi kertaa suurempi kuin a). Ja arvojen "väliin" ajätetään btyhjä (yleensä nollattu) 32 bitin tila; kun tuoteluettelo käsitellään, %"PRId64"32-bittinen arvo atämän välilyönnin kanssa tulkitaan yhdeksi 64-bittiseksi arvoksi.

Tällainen virhe voi ilmetä odottamatta siirrettäessä ohjelmakoodia toiselle alustalle, vaihdettaessa kääntäjää tai käännöstilaa.

Mahdollinen kokoero

C- ja C++-kielten määritelmät kuvaavat vain yleisimmät vaatimukset tietotyyppien koosta ja esityksestä. Siksi monilla alustoilla joidenkin muodollisesti erilaisten tietotyyppien esitystapa osoittautuu samaksi. Tämä aiheuttaa sen, että jotkut tyyppierot jäävät havaitsematta pitkään.

Esimerkiksi Win32-alustalla on yleisesti hyväksyttyä, että tyyppien intja koot long intovat samat (32 bittiä). Siten puhelu printf("%ld", 1)tai printf("%d", 1L)suoritetaan "oikein".

Tällainen virhe voi ilmetä odottamatta siirrettäessä ohjelmakoodia toiselle alustalle, vaihdettaessa kääntäjää tai käännöstilaa.

Kun kirjoitat ohjelmia C++-kielellä, tulee olla varovainen kokonaislukutyyppisten aliasten avulla ilmoitettujen muuttujien arvojen johtamisessa, erityisesti size_t, ja ptrdiff_t; C++-standardikirjaston muodollinen määritelmä viittaa ensimmäiseen C-standardiin (1990). Toinen C-standardi (1999) määrittelee kokomääritykset tyypeille size_tja useille muille tyypeille käytettäväksi samanlaisten objektien kanssa. ptrdiff_tMyös monet C++-toteutukset tukevat niitä.

koko_t s = 1 ; printf ( "%u" , s ); Tämä esimerkki sisältää virheen, joka voi ilmetä alustoissa, sizeof (unsigned int)joissa sizeof (size_t). koko_t s = 1 ; printf ( "%zu" , s ); Oikea tapa päätellä tyyppiobjektin arvo on size_tC-kielellä. Tyyppi ei täsmää, kun koko vastaa

Jos välitetyt argumentit ovat samankokoisia, mutta eri tyyppisiä, ohjelma toimii usein "melkein oikein" (ei aiheuta muistin käyttövirheitä), vaikka lähtöarvo on todennäköisesti merkityksetön. On huomattava, että parillisten kokonaislukutyyppien (etumerkit ja etumerkitön) sekoittaminen on sallittua, ei aiheuta määrittelemätöntä käyttäytymistä ja sitä käytetään joskus tarkoituksella käytännössä.

Kun käytetään muotomäärittelyä %s, argumenttiarvo, joka on muu kuin , kokonaisluku-, reaali- tai osoitintyyppiä char*, tulkitaan merkkijonon osoitteeksi. Tämä osoite voi yleisesti ottaen viitata mielivaltaisesti olemattomaan tai saavuttamattomaan muistialueeseen, mikä johtaa muistin käyttövirheeseen, tai muistialueeseen, joka ei sisällä viivaa, mikä johtaa järjettömään ulostuloon, mahdollisesti erittäin suureen. .

Muotoilumerkkijonon haavoittuvuus

Koska printf (ja muut perheen funktiot) voivat tulostaa muotomerkkijonon tekstin ilman muutoksia, jos se ei sisällä escape-sekvenssejä, niin komennon tekstin ulostulo on mahdollista
printf(text_to_print);
Jos teksti_tulostettava on saatu ulkoisista lähteistä (lue tiedostosta , saatu käyttäjältä tai käyttöjärjestelmältä), prosenttimerkin läsnäolo tuloksena olevassa merkkijonossa voi johtaa erittäin ei-toivottuihin seurauksiin (ohjelman jäädyttämiseen asti).

Väärä koodiesimerkki:
printf(" Current status: 99% stored.");
Tämä esimerkki sisältää erotussekvenssin "% s" , joka sisältää koodinvaihtomerkin (%), lipun (välilyönnin) ja merkkijonotietotyypin ( s ). Vastaanotettuaan ohjaussekvenssin funktio yrittää lukea osoittimen merkkijonoon pinosta. Koska funktiolle ei ole välitetty lisäparametreja, pinosta luettava arvo on määrittelemätön. Tuloksena oleva arvo tulkitaan osoittimeksi nollapäätteiseen merkkijonoon. Tällaisen "merkkijonon" tulos voi johtaa mielivaltaiseen muistivedostilaan, muistin käyttövirheeseen ja pinon vioittumiseen. Tämän tyyppistä haavoittuvuutta kutsutaan muotomerkkijonohyökkäykseksi .  [21]

Puskurin ylivuoto

Tulostettavien merkkien enimmäismäärä ei rajoita tulosta tulostavaa printf -toimintoa. Jos virheen tai laiminlyönnin seurauksena näyttöön tulee odotettua enemmän merkkejä, pahinta mitä voi tapahtua, on kuvan "tuhoaminen" näytöllä. Luotu analogisesti printf :n kanssa, sprintf - funktiota ei myöskään rajoitettu tuloksena olevan merkkijonon enimmäiskoon suhteen. Toisin kuin "infinite" -pääte, muisti, jonka sovellus varaa tuloksena olevalle merkkijonolle, on aina rajoitettu. Ja mikäli odotetut rajat ylitetään, tallennus tehdään muihin tietorakenteisiin kuuluville muistialueille (tai yleensä mahdottomille muistialueille, mikä tarkoittaa, että ohjelma kaatuu melkein kaikilla alustoilla). Kirjoittaminen mielivaltaisille muistialueille johtaa arvaamattomiin vaikutuksiin (jotka voivat ilmaantua paljon myöhemmin eikä ohjelmavirheen, vaan käyttäjän tietojen vioittumisen muodossa). Merkkijonon enimmäiskoon rajan puuttuminen on perustavanlaatuinen suunnitteluvirhe funktiota kehitettäessä. Tästä syystä sprintf- ja vsprintf- funktioiden tila on vaarallinen . Sen sijaan hän kehitti funktiot snprintf , vsnprintf , jotka ottavat lisäargumentin, joka rajoittaa tuloksena olevan merkkijonon enimmäismäärää. Swprintf- funktio, joka ilmestyi paljon myöhemmin (monitavuisten koodausten kanssa työskentelemiseen), ottaa tämän puutteen huomioon ja käyttää argumentin rajoittaakseen tuloksena olevaa merkkijonoa. (Siksi snwprintf- toimintoa ei ole ).

Esimerkki vaarallisesta kutsusta sprintf :lle:

charbuffer [65536]; char* nimi = hanki_käyttäjänimi_näppäimistöstä(); sprintf(puskuri, "Käyttäjänimi:%s", nimi);

Yllä oleva koodi olettaa implisiittisesti, että käyttäjä ei kirjoita 65 tuhatta merkkiä näppäimistöllä ja puskurin "pitäisi riittää". Mutta käyttäjä voi ohjata syötteen toisesta ohjelmasta tai silti kirjoittaa yli 65 000 merkkiä. Tässä tapauksessa muistialueet vioittuvat ja ohjelman käyttäytyminen muuttuu arvaamattomaksi.

Vaikeuksia käytössä

Tyyppitarkistuksen puute

Printf - perheen toiminnot käyttävät C - tietotyyppiä . Näiden tyyppien koot ja niiden suhteet voivat vaihdella alustasta toiseen. Esimerkiksi 64-bittisillä alustoilla valitusta mallista ( LP64 , LLP64 tai ILP64 ) riippuen int- ja long -tyyppien koot voivat vaihdella. Jos ohjelmoija asettaa muotomerkkijonon "melkein oikeaksi", koodi toimii yhdellä alustalla ja antaa väärän tuloksen toisella (joissakin tapauksissa saattaa johtaa tietojen vioittumiseen).

Koodi printf( "text address: 0x%X", "text line" );toimii esimerkiksi oikein 32-bittisellä alustalla ( ptrdiff_t - koko ja int -koko 32 bittiä) ja 64-bittisessä IPL64-mallissa (jossa ptrdiff_t- ja int - koot ovat 64-bittisiä), mutta antaa virheellisen tuloksen 64-bittisellä alustalla. -bitin alusta LP64- tai LLP64-mallissa, jossa ptrdiff_t:n koko on 64 bittiä ja int :n koko on 32 bittiä. [22]

Oracle Javassa dynaamisella tunnisteella käärittyjä tyyppejäprintf käytetään funktion analogissa , [6] Embarcadero Delphissä -  välikerros , [23] erilaisissa toteutuksissa C ++ : ssa [24]  - toimintojen ylikuormitus , C + :ssa + 20  - muuttujapohjia. Lisäksi muodot ( jne .) eivät määritä argumentin tyyppiä, vaan vain lähtömuotoa, joten argumentin tyypin muuttaminen voi aiheuttaa hätätilanteen tai rikkoa korkean tason logiikan (esim. taulukon asettelu) - mutta älä pilaa muistia. array of const%d%f

Standardoinnin puute

Ongelmaa pahentaa muotomerkkijonojen riittämätön standardointi eri kääntäjissä: esimerkiksi Microsoftin kirjastojen varhaiset versiot eivät tukeneet "%lld"(sinun piti määrittää "%I64d"). Microsoftin ja GNU:n välillä on edelleen jako tyypin mukaan size_t: %Iuedellinen ja %zujälkimmäinen. GNU C ei vaadi swprintfmerkkijonon enimmäispituutta funktiossa (sinun täytyy kirjoittaa snwprintf).

Kyvyttömyys järjestää argumentteja uudelleen

Perhefunktiot printfovat käteviä ohjelmistojen lokalisoinnissa : esimerkiksi se on helpompi kääntää kuin «You hit %s instead of %s.»merkkijonopätkät «You hit »ja . Mutta tässäkin on ongelma: on mahdotonta järjestää korvattuja merkkijonoja paikkoihin, jotta saadaan: . « instead of »«.»«Вы попали не в <2>, а в <1>.»

Oracle Javassa ja Embarcadero Delphissaprintf käytetyt laajennukset mahdollistavat edelleen argumenttien järjestämisen uudelleen.

printf-apuohjelma

POSIX -standardin sisällä kuvataan printf -apuohjelma , joka muotoilee argumentit sopivan kaavan mukaan, kuten printf -funktio .

Apuohjelmalla on seuraava kutsumuoto: , missä printf format [argument …]

• muoto  on muotomerkkijono, joka on syntaksilta samanlainen kuin printf -funktion muotomerkkijono .
• argumentti  on luettelo argumenteista (0 tai enemmän), jotka on kirjoitettu merkkijonomuodossa.

Toteutusesimerkkejä

• [yksi]
• [2]

Esimerkki 1 C (ohjelmointikieli)

#include <stdio.h> #include <locale.h> #define PI 3.141593 int main () { setlocale ( LC_ALL , "RUS" ); int numero = 7 ; float piirakat = 12,75 ; sisähinta = 7800 ; _ printf ( "%d kilpailijaa söi %f kirsikkapiirakkaa. \n " , numero , piirakat ); printf ( "Pi:n arvo on %f \n " , PI ); printf ( "Hyvästi! Taidesi maksaa liikaa (%c%d) \n " , '$' , 2 * hinta ); paluu 0 ; }

Esimerkki 2 C (ohjelmointikieli)

#include <stdio.h> #define SIVUT 959 int main () { printf ( "*%d* \n " , SIVUT ); printf ( "*%2d* \n " , SIVUT ); printf ( "*%10d* \n " , PAGES ); printf ( "*%-10d* \n " , SIVUT ); paluu 0 ; } /* Tulos: *959* *959* * 959* *959 * */

Esimerkki 3 C (ohjelmointikieli)

#include <stdio.h> #define BLURB "Aito jäljitelmä!" int main () { const double VUOKRA = 3852,99 ; printf ( "*%8f* \n " , VUOKRAA ); printf ( "*%e* \n " , VUOKRAA ); printf ( "*%4.2f* \n " , VUOKRAA ); printf ( "*%3.1f* \n " , VUOKRAA ); printf ( "*%10.3f* \n " , VUOKRAA ); printf ( "*%10.3E* \n " , VUOKRAA ); printf ( "*%+4.2f* \n " , VUOKRAA ); printf ( "%x %X %#x \n " , 31 , 31 , 31 ); printf ( "**%d**% d% d ** \n " , 42 , 42 , -42 ); printf ( "**%5d**%5.3d**%05d**%05.3d** \n " , 6 , 6 , 6 , 6 ); printf ( " \n " ); printf ( "[%2s] \n " , BLURB ); printf ( "[%24s] \n " , BLURB ); printf ( "[%24.5s] \n " , BLURB ); printf ( "[%-24.5s] \n " , BLURB ); paluu 0 ; } /* tulos *3852.990000* *3.852990e+03* *3852.99* *3853.0* * 3852.990* * 3.853E+03* *+3852.99* 1f 1F 0x1f **0 ** 2-42 ** 0 ** 2-42 ** **00006** 006** [Aito jäljitelmä!] [Aito jäljitelmä!] [Authe] [Authe ] */

Linkit

1. ↑ Lyhyt kuvaus BCPL-kielestä . Haettu 16. joulukuuta 2006. Arkistoitu alkuperäisestä 9. joulukuuta 2006. (määrätön)
2. ↑ B Kieliopas arkistoitu 6. heinäkuuta 2006.
3. ↑ Kuvaus sprintf - funktiosta Perl - dokumentaatiossa . Haettu 12. tammikuuta 2007. Arkistoitu alkuperäisestä 14. tammikuuta 2007. (määrätön)
4. ↑ Kuvaus Pythonin merkkijonotyyppien muotoiluoperaattorista Arkistoitu 9. marraskuuta 2006.
5. ↑ Kuvaus PHP :n printf -toiminnosta . Haettu 23. lokakuuta 2006. Arkistoitu alkuperäisestä 6. marraskuuta 2006. (määrätön)
6. ↑ 1 2 Kuvaus funktiosta java.io.PrintStream.printf() Java 1.5:ssä . Haettu 12. tammikuuta 2007. Arkistoitu alkuperäisestä 13. tammikuuta 2007. (määrätön)
7. ↑ Kuvaus printf - funktiosta Ruby - dokumentaatiossa . Haettu 3. joulukuuta 2006. Arkistoitu alkuperäisestä 5. joulukuuta 2006. (määrätön)
8. ↑ String.format- funktion kuvaus Lua-dokumentaatiossa . Käyttöpäivä: 14. tammikuuta 2010. Arkistoitu alkuperäisestä 15. marraskuuta 2013. (määrätön)
9. ↑ Muotoilutoiminnon kuvaus TCL- dokumentaatiossa . Haettu 14. huhtikuuta 2008. Arkistoitu alkuperäisestä 4. heinäkuuta 2007. (määrätön)
10. ↑ Kuvaus printf : n merkkijonokuviosta GNU Octave -dokumentaatiossa . Haettu 3. joulukuuta 2006. Arkistoitu alkuperäisestä 27. lokakuuta 2006. (määrätön)
11. ↑ Printf :n kuvaus Maple-dokumentaatiossa{{subst:AI}}
12. ↑ R. Fourer, D. M. Gay ja B. W. Kernighan. AMPL: A Modeling Language for Mathematical Programming, 2. painos Pacific Grove, CA: Brooks/Cole--Thomson Learning, 2003.
13. ↑ GNU Emacs Lisp Reference Manual, Formatting Strings Arkistoitu 27. syyskuuta 2007 Wayback Machinessa
14. ↑ Printf - moduulin kuvaus OCaml - dokumentaatiossa . Haettu 12. tammikuuta 2007. Arkistoitu alkuperäisestä 13. tammikuuta 2007. (määrätön)
15. ↑ Printf - moduulin kuvaus Haskell - dokumentaatiossa . Haettu 23. kesäkuuta 2015. Arkistoitu alkuperäisestä 23. kesäkuuta 2015. (määrätön)
16. ↑ std::println! - Ruostetta . doc.rust-lang.org. Haettu 24. heinäkuuta 2016. Arkistoitu alkuperäisestä 18. elokuuta 2016. (määrätön)
17. ↑ muoto . www.freepascal.org. Haettu 7. joulukuuta 2016. Arkistoitu alkuperäisestä 24. marraskuuta 2016. (määrätön)
18. ↑ fmt - Go-ohjelmointikieli . golang.org. Haettu 25. maaliskuuta 2020. Arkistoitu alkuperäisestä 4. huhtikuuta 2020. (määrätön)
19. ↑ §7.19.6.1 ISO/IEC 9899:TC2
20. ↑ § 7.11.1.1 ISO/IEC 9899:TC2, LC_NUMERIC määrittelee erityisesti desimaalierottimen esitysmuodon.
21. ↑ Printf-haavoittuvuuden kuvaus, Robert C. Seacord: Secure Coding C- ja C++-kielillä. Addison Wesley, syyskuu, 2005. ISBN 0-321-33572-4
22. ↑ Kuvaus ongelmista sovellusten siirtämisessä 32 - 64 - bittisestä arkkitehtuurista . Haettu 14. joulukuuta 2006. Arkistoitu alkuperäisestä 8. maaliskuuta 2007. (määrätön)
23. ↑ System.SysUtils.Format Arkistoitu 11. tammikuuta 2013 Wayback Machinessa 
24. ↑ Esimerkiksi boost::formatdokumentaatio , arkistoitu 26. maaliskuuta 2013 Wayback Machinessa 

Lähteet

• printf , fprintf , snprintf , vfprintf , vprintf , vsnprintf , vsprintf standardissa ISO/IEC 9899:TC2 (ISO C) [3]
• printf , fprintf , sprintf , snprintf Single Unix -standardissa [ 4 ]
• vprintf , vfprintf , vsprintf , vsnprintf POSIX - standardissa [5]
• wprintf , swprintf , wprintf POSIX - standardissa [6]
• vfwprintf , vswprintf , vwprintf POSIX - standardissa [7]
• wsprintf MSDN:ssä [ 8]
• wvnsprintf MSDN:ssä [9]
• wnsprintf MSDN:ssä [10]
• wvsprintf MSDN:ssä [11]
• wnsprintf MSDN:ssä [12]
• asprintf , vasprintf man -sivuilla Linuxissa [13] , libc - dokumentaatiossa [14]
• Katso muotomerkkijonosyntaksin kuvaus libc -käsikirjasta [15] .
• Muotoilumerkkijonon kuvaus Microsoft Visual Studio 2005 :n dokumentaatiossa [16]
• Kuvaus register_printf_function [17] , [18]
• Ohjelmointikieli C. Luennot ja harjoitukset. Kirjailija: Stephen Prata. ISBN 978-5-8459-1950-2 , 978-0-321-92842-9; 2015

Katso myös

• Xi
• scanf
• Ohjelmointikielen standardikirjasto
• C Standard Library
• POSIX
• cout

Unix-komennot
Apuohjelmat POSIX.1-2008 järjestelmänvalvoja alias ar asa klo awk perusnimi erä eKr bg c99 cal kissa CD cflow chgrp chmod chown cksum cmp comm komento puristaa cp crontab csplit ctags leikata cxref Päivämäärä dd delta df ero dirname du kaiku toim env esim laajentaa expr väärä fc fg tiedosto löytö taita linnake 77 kiinnitysyksikkö gencat saada getconf getopts grep hash pää iconv id ipcrm ipcs työpaikkoja liittyä seuraan tappaa lex linkki ln alue localedef metsuri lokinimi lp ls m4 mailx tehdä mies viesti mkdir mkfifo lisää mv newgrp kiva nl nm nohup od liitä laastari pathchk pax PR printf prs ps pwd qalter qdel qhold qmove qmsg qrerun qrls qselect qsig qstat qsub lukea Renice rm rmdel rmdir sact sccs sed sh nukkua järjestellä jakaa jouset nauhat stty välilehdet häntää puhua tee testata aika kosketus tput tr totta tsort tty tyyppi ulimit umask unalias sinä nimi purkaa laajentaa unget uniq poista linkitys uucp uudecode uuencode ustat uux val vi odota WC mitä WHO kirjoittaa xargs yacc zcat
GNU Coreutils Tiedoston apuohjelmat chgrp chown chmod cp dd df ohj dircolors asenna ln ls mkdir mkfifo mknod mv rm rmdir silputa synkronoida kosketus vdir Teksti-apuohjelmat kissa cksum comm csplit leikata laajentaa fmt taita pää liittyä seuraan md5sum nl od liitä ptx pr sha1sum järjestellä jakaa summa tac häntää tr tsort laajentaa uniq WC Shell-apuohjelmat perusnimi chroot Päivämäärä dirname du kaiku env expr tekijä väärä ryhmät hostid id linkki lokinimi kiva nohup pathchk pinkki printenv printf pwd lue linkki sek nukkua stat stty tee testata totta tty sinä nimi poista linkitys käyttäjiä WHO kuka olen Joo