Disambigui il termine "Funzione di supporto". Una definizione è una comodità
funzione che usi tutto il tempo solo per fare un lavoro. quelli
può vivere nel namespace principale e avere le proprie intestazioni, ecc.
L'altra definizione della funzione helper è una funzione di utilità per una singola classe o classe.
// a general helper
template <class T>
bool isPrinter(T& p){
return (dynamic_cast<Printer>(p))? true: false;
}
// specific helper for printers
namespace printer_utils {
namespace HP {
print_alignment_page() { printAlignPage();}
}
namespace Xerox {
print_alignment_page() { Alignment_Page_Print();}
}
namespace Canon {
print_alignment_page() { AlignPage();}
}
namespace Kyocera {
print_alignment_page() { Align(137,4);}
}
namespace Panasonic {
print_alignment_page() { exec(0xFF03); }
}
} //namespace
Ora isPrinter è disponibile per qualsiasi codice inclusa la sua intestazione,
ma print_alignment_page richiede a
using namespace printer_utils::Xerox; direttiva.
Si può anche fare riferimento come
Canon::print_alignment_page();
per essere più chiari.
Il C ++ STL ha lo spazio dei nomi std:: che copre quasi tutto il suo
classi e funzioni, ma suddivide categoricamente in più di 17 diverse intestazioni per consentire al codificatore di estrarre i nomi delle classi, i nomi delle funzioni, ecc. se vogliono scrivere da soli.
In effetti, NON è consigliato utilizzare using namespace std; in un file di intestazione o, come spesso accade, come prima riga all'interno di main() . std:: è 5 lettere e spesso sembra un lavoretto per prefigurare la funzione che si vuole usare (specialmente std::cout e std::endl !) ma ha uno scopo.
Il nuovo C ++ 11 ha alcuni sotto-namespace in esso per servizi speciali come
std::placeholders,
std::string_literals,
std::chrono,
std::this_thread,
std::regex_constants
che può essere portato per l'uso.
Una tecnica utile è la composizione dello spazio dei nomi . Uno definisce uno spazio dei nomi personalizzato per contenere gli spazi dei nomi necessari per il tuo particolare file .cpp e usa quello invece di un gruppo di istruzioni using per ogni cosa in uno spazio dei nomi che potresti aver bisogno.
#include <iostream>
#include <string>
#include <vector>
namespace Needed {
using std::vector;
using std::string;
using std::cout;
using std::endl;
}
int main(int argc, char* argv[])
{
/* using namespace std; */
// would avoid all these individual using clauses,
// but this way only these are included in the global
// namespace.
using namespace Needed; // pulls in the composition
vector<string> str_vec;
string s("Now I have the namespace(s) I need,");
string t("But not the ones I don't.");
str_vec.push_back(s);
str_vec.push_back(t);
cout << s << "\n" << t << endl;
// ...
Questa tecnica limita l'esposizione all'intero std:: namespace ( è grande! ) e consente di scrivere codice più pulito per le linee di codice più comuni che le persone scrivono più spesso.