Piccolo Cheat Sheet per il C++ parte 7

  • I/O su file

void ifstream::open(NOME_FILE, modalità) // modalità default = ios::in

void ofstream::open(NOME_FILE, modalità) // modalità default = ios:out

void fstream::open(NOME_FILE, modalità) // modalità default = ios::in|ios::out

es:

ofstream out;

out.open("pippo");

// la stessa cosa si può fare banalmente con:

ofstream out("pippo");

out.close();

  • file binari

istream &read(char *buf, streamsize num);

ostream &write(const char *buf, streamsize num);

buf deve essere definito come array di caratteri, oppure (ad esempio se buf è una struttura, deve essere castato esplicitamente ad array di caratteri (unsigned char *)

  • funzioni varie

bool eof(); // in.eof()

istream &ignore(streamsize num=1, int_type delim=EOF); // leggere ed ignora num caratteri

int_t peek(); // restituisce il prossimo carattere dello stream, senza rimuoverlo dallo stream stesso

istream &putback(char c); // rimette nello stream l'ultimo carattere letto

ostream &flush();

istream &seekg(off_type offset, seekdir origine); // sposta il puntatore di lettura del file

ostram &seekp(off_type offset, seekdir origine); // sposta il puntatore di scrittura del file

origine = ios::beg (inizio), ios::cur (corrente), ios::end (fine)

pos_type tellg(); // posizione puntatore in lettura

pos_type tellp(); // posizione puntatore in scrittura

  • Identificazione runtime dei tipi (RTTI)

type_info typeid(oggetto); // restituisce un oggetto di tipo type_info che rappresenta il tipo del parametro, funziona anche con classi template (restituisce tipo1<tipoA>)

typeid(oggetto).name(); // restituisce il nome del tipo dell'oggetto

  • operazioni di cast

dynamic_cast<tipo_destinazione> (espressione) // effettua il cast a runtime verificando se è possibile. tipo_destinazione deve essere un puntatore o un indirizzo, così come "elemento", se non ha successo restituisce null (nel caso di puntatori) o solleva una bad_cast (nel caso di indirizzi)

dynamic_cast<tipo1<tipoA> (espressione) // per classi template

const_cast<tipo> (espressione) // permette di rimuovere "const" e/o "volatile" dalla dichiarazione di una variabile (quindi ad esempio posso modificare una variabile dichiarata con const), tipo deve essere lo stesso di espressione a meno di "const" e/o "volatile"

static_cast<tipo> (espressione) // è la stessa cosa del cast vecchio stile (alla "C"), non effettua verifiche

reinterpret_cast<tipo> (espressione) // converte un tipo in uno completamente scorrelato, può fare grossi danni

  • namespace

namespace NOME {

...

}

NOME::var;

nome::oggetto;

using NOME;

using NOME::var; // solo var diventa visibile senza riportare il nome del namespace

namespace { // namespace senza nome, serve per rendere invisibili all'esterno gli oggetti/variabili/funzioni qui definiti

int k;

}

è possibile dichiarare più volte un namespace, l’unione di queste dichiarazioni rappresenterà il namespace complessivo

using namespace std; // namespace per libreria standard

  • overloading di conversioni a tipi

è possibile dichiarare delle funzioni di conversione tra tipi ad-hoc

class tipo {

int i;

operator int() {return i}

...

}

tipo oggetto;

int j;

j = oggetto; // converto oggetto in int, quindi j = i

  • funzioni const e mutable

una funzione dichiarata con const non permette le modifiche a this (quindi all’oggetto che la contiene)

int f() const;

f() {

...

}

se dichiaro qualche attributo "mutable" allora posso modificarlo anche all’interno di funzioni const

mutable i;

int f() const {

i = X;

}

  • funzioni membro volatile

rendono this un puntatore volatile

void f() volatile;

  • costruttore esplicito

class myclass {

...

explicit myclass(int i);

...

}

myclass b(5); //ok

myclass b = 5; //errore

  • specifiche di linking

extern "linguaggio" prototipo_funzione;

extern "C" prototipo_funzione; // link della funzione secondo regole C

  • I/O su array

come con sprintf e sscanf

ostrstream ostr(char *buf, streamsize size, openmode mode=iso::out);

char str[80];

ostrstream outs(str, sizeof(str));

outs << "pippo";

istrstream istr(const char *buf);

istrstream ins(str);

ins >> var;

strstream iostr(char *buf, streamsize size, openmode mode=ios::in!ios::out);

ostrstream(); // per lunghezza variabile

ostrstream ostr;

char *p;

ostr << "pippo" << endl;

p = ostr.str(); // restituisce l'array;

Lascia un commento

Inserisci i tuoi dati qui sotto o clicca su un'icona per effettuare l'accesso:

Logo WordPress.com

Stai commentando usando il tuo account WordPress.com. Chiudi sessione / Modifica )

Foto Twitter

Stai commentando usando il tuo account Twitter. Chiudi sessione / Modifica )

Foto di Facebook

Stai commentando usando il tuo account Facebook. Chiudi sessione / Modifica )

Google+ photo

Stai commentando usando il tuo account Google+. Chiudi sessione / Modifica )

Connessione a %s...