Désambiguïsez le terme "fonction d'assistance". Une définition est une fonction pratique que vous utilisez tout le temps pour faire votre travail. Ceux-ci peuvent vivre dans l'espace de noms principal et avoir leurs propres en-têtes, etc. L'autre définition de la fonction d'assistance est une fonction utilitaire pour une classe ou une famille de classes.
// 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
Now isPrinterest disponible pour tout code incluant son en-tête, mais print_alignment_pagenécessite une
using namespace printer_utils::Xerox;directive. On peut aussi le référencer comme
Canon::print_alignment_page();
être plus clair.
La STL C ++ a un std::espace de noms qui couvre la quasi-totalité de ses classes et fonctions, mais il les divise catégoriquement en plus de 17 en-têtes différents pour permettre au codeur d'obtenir le nom de classe, le nom de fonction, etc. s'il souhaite écrire. les leurs.
En fait, il n'est PAS recommandé d'utiliser using namespace std;dans un fichier d'en-tête ou, comme on le fait souvent, comme première ligne à l'intérieur main(). std::est de 5 lettres et semble souvent une corvée à précéder de la fonction que l'on veut utiliser (surtout std::coutet std::endl!), mais cela sert à quelque chose.
Le nouveau C ++ 11 contient des sous-espaces de noms pour des services spéciaux tels que
std::placeholders,
std::string_literals,
std::chrono,
std::this_thread,
std::regex_constants
qui peut être amené à être utilisé.
Une technique utile est la composition d'espace de noms . On définit un espace de noms personnalisé pour contenir les espaces de noms dont vous avez besoin pour votre .cppfichier particulier et les utiliser à la place d'un ensemble d' usinginstructions pour chaque élément d'un espace de noms dont vous pourriez avoir besoin.
#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;
// ...
Cette technique limite l'exposition à l'ensemble std:: namespace( c'est grand! ) Et permet d'écrire un code plus propre pour les lignes de code les plus courantes écrites par les utilisateurs.
staticmot-clé?