Comment permettre à la fonction de modèle pour avoir des amis (comme) l'accès?

Comment modifier le code suivant pour permettre la fonction de modèle ask_runUI() à utiliser s_EOF sans faire s_EOF public?

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
class AskBase {
protected:
std::string m_prompt;
std::string m_answer; 
virtual bool validate(std::string a_response) = 0;
public:
AskBase(std::string a_prompt):m_prompt(a_prompt){}
std::string prompt(){return m_prompt;}
std::string answer(){return m_answer;}
static int const s_EOF = -99;
static int const s_BACKUP = -1;
static int const s_OK = 1;
int ask_user();
};
template<typename T> class Ask : public AskBase{
public:
Ask(std::string a_prompt):AskBase(a_prompt){}
bool validate(std::string a_response);
};
template<> bool Ask<std::string>::validate(std::string a_response){return true;}
template<> bool Ask<int>::validate(std::string a_response){int intAnswer;
return (std::stringstream(a_response) >> intAnswer);}
int AskBase::ask_user(){
for(;;){
std::cout << "Enter " << m_prompt;
std::string response;
getline(std::cin, response);
if (std::cin.eof())
return s_EOF;
else if (response == "^")
return s_BACKUP;
else if (validate(response)){
m_answer = response;
return s_OK;
}
}
return s_EOF;
}
template<typename T> int ask_runUI(T& a_ui){
int status = AskBase::s_OK;
for (typename T::iterator ii=a_ui.begin();
status!=AskBase::s_EOF && ii!=a_ui.end();
ii+=((status==AskBase::s_BACKUP)?((ii==a_ui.begin())?0:-1):1)
status = (*ii)->ask_user();
return (status == AskBase::s_OK);
}
int main(){
std::vector<AskBase*> ui;
ui.push_back(new Ask<std::string>("your name: "));
ui.push_back(new Ask<int>("your age: "));
if (ask_runUI(ui))
for (std::vector<AskBase*>::iterator ii=ui.begin(); ii!=ui.end(); ++ii)
std::cout << (*ii)->prompt() << (*ii)->answer() << std::endl;
else
std::cout << "\nEOF\n";
}
  • La prochaine fois, veuillez utiliser int ask_runUI() (le ` marquer comme code).
  • Si vous êtes de retour le nombre, pourquoi devrait-il en être privé?
  • J'ai développé l'exemple de montrer que seule AskBase::ask_user() renvoie s_EOF qui n'est utilisé que par ask_runUI().
InformationsquelleAutor CW Holeman II | 2009-05-28
  1. 28

    Si vous voulez un modèle de la fonction d'un ami, vous devez l'indiquer dans la déclaration de classe. Modifiez la ligne qui déclare l'ami de la fonction pour cela:

    template <typename T> 
friend int ask_runUI(T& a_ui);

    Maintenant, si votre classe est elle-même un modèle, les choses deviennent beaucoup plus compliquées. Modèle d'amis ne sont pas trivial à faire correctement. Pour cela, je vais vous référer à ce C++ FAQ Lite dit sur le sujet.

    InformationsquelleAutor Michael Kristofik
  2. 2

    Cela a fonctionné pour moi!

    class AskBase {
public:
AskBase(){}
template<typename T> 
friend int ask_runUI(T& a_ui);
private:
static int const    s_EOF = -99;
static int const    s_BACKUP = -1;
static int const    s_NULL = 0;
static int const    s_OK = 1;
};
//int ask_runUI()
template<typename T> 
int ask_runUI(T& a_ui)
{
return AskBase::s_NULL;
}
    • C'est le classique de l'anti-modèle pour les demandes d'amitié d'un modèle de méthode. C'est fondamentalement la même que faire de tous les membres du public que n'importe qui peut maintenant écrire leur propre version de ask_runUI()
    • Ils peuvent, mais seront-ils à le faire par accident, sans s'en rendre compte c'est ce qu'ils font? Surtout si ask_UI est dans le même espace de nom que la classe, si ils vont fouiller à l'intérieur d'une classe de l'interface, puis sûrement, ils savent qu'ils vont briser l'encapsulation?
    InformationsquelleAutor aJ.
  3. -2

    La plus simple est probablement de remplacer static int const membres de l'énumération et plaisante pas avec la friends:

    
class AskBase {
public:
enum { Eof = -99, Null = 0, Ok = 1, Backup = -1 };
...
};
    • -1. Je ne vois pas en quoi cela change quoi que ce soit -- votre enum, qui vous avez déclaré publiquement, à chaque matériel équivalent à faire de la static const int membres du public. Si il ya une distinction que j'ai manqué, s'il vous plaît dire et je vais revenir.
    • La distinction est que le compilateur n'a pas à allouer de l'espace pour la statique des variables membres. L'avantage est que c'est SIMPLE.
    • Eh bien, j'ai fait quelques recherches et c'est encore plus bizarre que je ne le pensais. Pour l'un, si vous il suffit de déclarer et initialiser le static const int membres à l'intérieur de la définition de la classe sans définir au niveau de l'espace de noms (c'est à dire sans écriture "statict const int AskBase::s_Eof;" etc. au niveau de l'espace de noms) alors aucun espace ne sera jamais affecté. MAIS, le compilateur ne vous permettent de vous référer à s_Eof comme une rvalue (par exemple, la liaison à un non-const ref échoue au moment de lien!!) Voir ici: stackoverflow.com/questions/272900/..., en particulier Richard Corden de réponse.
    InformationsquelleAutor Nikolai Fetissov