Je ne peux donc pas donner de valeurs aux constantes dans la liste
d'initialisation puisque les valeurs ne sont pas encore connues.
Je ne peux donc pas donner de valeurs aux constantes dans la liste
d'initialisation puisque les valeurs ne sont pas encore connues.
Je ne peux donc pas donner de valeurs aux constantes dans la liste
d'initialisation puisque les valeurs ne sont pas encore connues.
On Sat, 12 Apr 2008 14:52:10 +0200, David Côme :Je ne peux donc pas donner de valeurs aux constantes dans la liste
d'initialisation puisque les valeurs ne sont pas encore connues.
class C
{
public:
C (std::string const&);
private:
int const a;
int const b;
};
C::C (std::string const& param)
: a (GetParametre (param, 1))
, b (GetParametre (param, 2))
{}
Où
GetParametre (string const&, unsigned int n)
est bien sûr une fonction qui découpe la chaîne et renvoie le n-ième
entier.
On Sat, 12 Apr 2008 14:52:10 +0200, David Côme <davidcome@wanadoo.fr>:
Je ne peux donc pas donner de valeurs aux constantes dans la liste
d'initialisation puisque les valeurs ne sont pas encore connues.
class C
{
public:
C (std::string const&);
private:
int const a;
int const b;
};
C::C (std::string const& param)
: a (GetParametre (param, 1))
, b (GetParametre (param, 2))
{}
Où
GetParametre (string const&, unsigned int n)
est bien sûr une fonction qui découpe la chaîne et renvoie le n-ième
entier.
On Sat, 12 Apr 2008 14:52:10 +0200, David Côme :Je ne peux donc pas donner de valeurs aux constantes dans la liste
d'initialisation puisque les valeurs ne sont pas encore connues.
class C
{
public:
C (std::string const&);
private:
int const a;
int const b;
};
C::C (std::string const& param)
: a (GetParametre (param, 1))
, b (GetParametre (param, 2))
{}
Où
GetParametre (string const&, unsigned int n)
est bien sûr une fonction qui découpe la chaîne et renvoie le n-ième
entier.
Je recois en paramètre d'une classe une chaîne qui contient
plusieurs valeurs (des ints pour être précis). Dans mon
constructeur, je récupère ces variables via des *stringstream.
Jusque là, pas de problème.
La difficulté vient du fait que je souhaite ensuite affecter
les valeurs obtenues à des variables constantes car les
valeurs récupérées sont les valeurs que doivent avoir les
variables constantes.
Je ne peux donc pas donner de valeurs aux constantes dans la
liste d'initialisation puisque les valeurs ne sont pas encore
connues.
Une idée ?
Je recois en paramètre d'une classe une chaîne qui contient
plusieurs valeurs (des ints pour être précis). Dans mon
constructeur, je récupère ces variables via des *stringstream.
Jusque là, pas de problème.
La difficulté vient du fait que je souhaite ensuite affecter
les valeurs obtenues à des variables constantes car les
valeurs récupérées sont les valeurs que doivent avoir les
variables constantes.
Je ne peux donc pas donner de valeurs aux constantes dans la
liste d'initialisation puisque les valeurs ne sont pas encore
connues.
Une idée ?
Je recois en paramètre d'une classe une chaîne qui contient
plusieurs valeurs (des ints pour être précis). Dans mon
constructeur, je récupère ces variables via des *stringstream.
Jusque là, pas de problème.
La difficulté vient du fait que je souhaite ensuite affecter
les valeurs obtenues à des variables constantes car les
valeurs récupérées sont les valeurs que doivent avoir les
variables constantes.
Je ne peux donc pas donner de valeurs aux constantes dans la
liste d'initialisation puisque les valeurs ne sont pas encore
connues.
Une idée ?
Fabien a montré la solution classique, mais il faut signaler que
s'il s'agit de plusieurs valeurs, dans une seule chaîne de
caractères, la solution est loin d'être optimale, parce qu'il
faudrait récréer la istringstream pour chaque valeur, sautant
les valeurs qu'on ne recherche pas chaque fois.
Fabien a montré la solution classique, mais il faut signaler que
s'il s'agit de plusieurs valeurs, dans une seule chaîne de
caractères, la solution est loin d'être optimale, parce qu'il
faudrait récréer la istringstream pour chaque valeur, sautant
les valeurs qu'on ne recherche pas chaque fois.
Fabien a montré la solution classique, mais il faut signaler que
s'il s'agit de plusieurs valeurs, dans une seule chaîne de
caractères, la solution est loin d'être optimale, parce qu'il
faudrait récréer la istringstream pour chaque valeur, sautant
les valeurs qu'on ne recherche pas chaque fois.
James Kanze writes:Fabien a montré la solution classique, mais il faut signaler que
s'il s'agit de plusieurs valeurs, dans une seule chaîne de
caractères, la solution est loin d'être optimale, parce qu'il
faudrait récréer la istringstream pour chaque valeur, sautant
les valeurs qu'on ne recherche pas chaque fois.
Quel manque d'imagination!
class C
{
public:
C(std::string const&);
inline int getA(void) const {return a;}
inline int getB(void) const {return b;}
private:
int const a;
int const b;
int getParameter(std::string const& arguments,unsigned int n);
};
C::C(std::string const& param)
: a(getParameter(param,1)),
b(getParameter(param,2))
{}
int C::getParameter(std::string const& arguments,unsigned int n){
typedef std::map<std::string,std::vector<int> > ParameterCache;
static ParameterCache cache;
ParameterCache::iterator parametersche.find(arguments);
if(parameters=che.end()){
std::istringstream in(arguments);
std::vector<int> parsedArgs;
while(not(in.eof())){
int argument;
in>>argument;
parsedArgs.push_back(argument);
}
cache[arguments]=parsedArgs;
parametersche.find(arguments);
}
if(parameters->second.size()<=n){
throw Error("Too few arguments");
}
return(parameters->second[n]);
}
int main(void){
C c0("0 1 2 3");
C c1("10 11 12 13");
std::cout<<"c0: "<<c0.getA()<<" "<<c0.getB()<<std::endl;
std::cout<<"c1: "<<c1.getA()<<" "<<c1.getB()<<std::endl;
return(0);
}
/*
-*- mode: compilation; default-directory: "~/src/miscellaneous/tests-c++/" -*-
Compilation started at Sun Apr 13 15:38:52
g++ -o const-member const-member.c++ && ./const-member
c0: 1 2
c1: 11 12
Compilation finished at Sun Apr 13 15:38:57
*/
James Kanze <james.ka...@gmail.com> writes:
Fabien a montré la solution classique, mais il faut signaler que
s'il s'agit de plusieurs valeurs, dans une seule chaîne de
caractères, la solution est loin d'être optimale, parce qu'il
faudrait récréer la istringstream pour chaque valeur, sautant
les valeurs qu'on ne recherche pas chaque fois.
Quel manque d'imagination!
class C
{
public:
C(std::string const&);
inline int getA(void) const {return a;}
inline int getB(void) const {return b;}
private:
int const a;
int const b;
int getParameter(std::string const& arguments,unsigned int n);
};
C::C(std::string const& param)
: a(getParameter(param,1)),
b(getParameter(param,2))
{}
int C::getParameter(std::string const& arguments,unsigned int n){
typedef std::map<std::string,std::vector<int> > ParameterCache;
static ParameterCache cache;
ParameterCache::iterator parameters=cache.find(arguments);
if(parameters==cache.end()){
std::istringstream in(arguments);
std::vector<int> parsedArgs;
while(not(in.eof())){
int argument;
in>>argument;
parsedArgs.push_back(argument);
}
cache[arguments]=parsedArgs;
parameters=cache.find(arguments);
}
if(parameters->second.size()<=n){
throw Error("Too few arguments");
}
return(parameters->second[n]);
}
int main(void){
C c0("0 1 2 3");
C c1("10 11 12 13");
std::cout<<"c0: "<<c0.getA()<<" "<<c0.getB()<<std::endl;
std::cout<<"c1: "<<c1.getA()<<" "<<c1.getB()<<std::endl;
return(0);
}
/*
-*- mode: compilation; default-directory: "~/src/miscellaneous/tests-c++/" -*-
Compilation started at Sun Apr 13 15:38:52
g++ -o const-member const-member.c++ && ./const-member
c0: 1 2
c1: 11 12
Compilation finished at Sun Apr 13 15:38:57
*/
James Kanze writes:Fabien a montré la solution classique, mais il faut signaler que
s'il s'agit de plusieurs valeurs, dans une seule chaîne de
caractères, la solution est loin d'être optimale, parce qu'il
faudrait récréer la istringstream pour chaque valeur, sautant
les valeurs qu'on ne recherche pas chaque fois.
Quel manque d'imagination!
class C
{
public:
C(std::string const&);
inline int getA(void) const {return a;}
inline int getB(void) const {return b;}
private:
int const a;
int const b;
int getParameter(std::string const& arguments,unsigned int n);
};
C::C(std::string const& param)
: a(getParameter(param,1)),
b(getParameter(param,2))
{}
int C::getParameter(std::string const& arguments,unsigned int n){
typedef std::map<std::string,std::vector<int> > ParameterCache;
static ParameterCache cache;
ParameterCache::iterator parametersche.find(arguments);
if(parameters=che.end()){
std::istringstream in(arguments);
std::vector<int> parsedArgs;
while(not(in.eof())){
int argument;
in>>argument;
parsedArgs.push_back(argument);
}
cache[arguments]=parsedArgs;
parametersche.find(arguments);
}
if(parameters->second.size()<=n){
throw Error("Too few arguments");
}
return(parameters->second[n]);
}
int main(void){
C c0("0 1 2 3");
C c1("10 11 12 13");
std::cout<<"c0: "<<c0.getA()<<" "<<c0.getB()<<std::endl;
std::cout<<"c1: "<<c1.getA()<<" "<<c1.getB()<<std::endl;
return(0);
}
/*
-*- mode: compilation; default-directory: "~/src/miscellaneous/tests-c++/" -*-
Compilation started at Sun Apr 13 15:38:52
g++ -o const-member const-member.c++ && ./const-member
c0: 1 2
c1: 11 12
Compilation finished at Sun Apr 13 15:38:57
*/
James Kanze writes:Fabien a montré la solution classique, mais il faut signaler que
s'il s'agit de plusieurs valeurs, dans une seule chaîne de
caractères, la solution est loin d'être optimale, parce qu'il
faudrait récréer la istringstream pour chaque valeur, sautant
les valeurs qu'on ne recherche pas chaque fois.
Quel manque d'imagination!
#include <ciso646>
#include <map>
#include <string>
#include <vector>
#include <sstream>
#include <iostream>
#include <iterator>
#include <exception>
class Error:public std::exception {
std::string message;
public:
Error(std::string const& aMessage):message(aMessage){};
~Error(void)throw(){};
const char* what(void){return(message.c_str());}
};
class C
{
public:
C(std::string const&);
inline int getA(void) const {return a;}
inline int getB(void) const {return b;}
private:
int const a;
int const b;
int getParameter(std::string const& arguments,unsigned int n);
};
C::C(std::string const& param)
: a(getParameter(param,1)),
b(getParameter(param,2))
{}
int C::getParameter(std::string const& arguments,unsigned int n){
typedef std::map<std::string,std::vector<int> > ParameterCache;
static ParameterCache cache;
ParameterCache::iterator parametersÊche.find(arguments);
if(parameters=Êche.end()){
std::istringstream in(arguments);
std::vector<int> parsedArgs;
while(not(in.eof())){
int argument;
in>>argument;
parsedArgs.push_back(argument);
}
cache[arguments]=parsedArgs;
parametersÊche.find(arguments);
}
if(parameters->second.size()<=n){
throw Error("Too few arguments");
}
return(parameters->second[n]);
}
int main(void){
C c0("0 1 2 3");
C c1("10 11 12 13");
std::cout<<"c0: "<<c0.getA()<<" "<<c0.getB()<<std::endl;
std::cout<<"c1: "<<c1.getA()<<" "<<c1.getB()<<std::endl;
return(0);
}
/*
-*- mode: compilation; default-directory:
"~/src/miscellaneous/tests-c++/" -*-
Compilation started at Sun Apr 13 15:38:52
g++ -o const-member const-member.c++ && ./const-member
c0: 1 2
c1: 11 12
Compilation finished at Sun Apr 13 15:38:57
*/
James Kanze <james.kanze@gmail.com> writes:
Fabien a montré la solution classique, mais il faut signaler que
s'il s'agit de plusieurs valeurs, dans une seule chaîne de
caractères, la solution est loin d'être optimale, parce qu'il
faudrait récréer la istringstream pour chaque valeur, sautant
les valeurs qu'on ne recherche pas chaque fois.
Quel manque d'imagination!
#include <ciso646>
#include <map>
#include <string>
#include <vector>
#include <sstream>
#include <iostream>
#include <iterator>
#include <exception>
class Error:public std::exception {
std::string message;
public:
Error(std::string const& aMessage):message(aMessage){};
~Error(void)throw(){};
const char* what(void){return(message.c_str());}
};
class C
{
public:
C(std::string const&);
inline int getA(void) const {return a;}
inline int getB(void) const {return b;}
private:
int const a;
int const b;
int getParameter(std::string const& arguments,unsigned int n);
};
C::C(std::string const& param)
: a(getParameter(param,1)),
b(getParameter(param,2))
{}
int C::getParameter(std::string const& arguments,unsigned int n){
typedef std::map<std::string,std::vector<int> > ParameterCache;
static ParameterCache cache;
ParameterCache::iterator parametersÊche.find(arguments);
if(parameters=Êche.end()){
std::istringstream in(arguments);
std::vector<int> parsedArgs;
while(not(in.eof())){
int argument;
in>>argument;
parsedArgs.push_back(argument);
}
cache[arguments]=parsedArgs;
parametersÊche.find(arguments);
}
if(parameters->second.size()<=n){
throw Error("Too few arguments");
}
return(parameters->second[n]);
}
int main(void){
C c0("0 1 2 3");
C c1("10 11 12 13");
std::cout<<"c0: "<<c0.getA()<<" "<<c0.getB()<<std::endl;
std::cout<<"c1: "<<c1.getA()<<" "<<c1.getB()<<std::endl;
return(0);
}
/*
-*- mode: compilation; default-directory:
"~/src/miscellaneous/tests-c++/" -*-
Compilation started at Sun Apr 13 15:38:52
g++ -o const-member const-member.c++ && ./const-member
c0: 1 2
c1: 11 12
Compilation finished at Sun Apr 13 15:38:57
*/
James Kanze writes:Fabien a montré la solution classique, mais il faut signaler que
s'il s'agit de plusieurs valeurs, dans une seule chaîne de
caractères, la solution est loin d'être optimale, parce qu'il
faudrait récréer la istringstream pour chaque valeur, sautant
les valeurs qu'on ne recherche pas chaque fois.
Quel manque d'imagination!
#include <ciso646>
#include <map>
#include <string>
#include <vector>
#include <sstream>
#include <iostream>
#include <iterator>
#include <exception>
class Error:public std::exception {
std::string message;
public:
Error(std::string const& aMessage):message(aMessage){};
~Error(void)throw(){};
const char* what(void){return(message.c_str());}
};
class C
{
public:
C(std::string const&);
inline int getA(void) const {return a;}
inline int getB(void) const {return b;}
private:
int const a;
int const b;
int getParameter(std::string const& arguments,unsigned int n);
};
C::C(std::string const& param)
: a(getParameter(param,1)),
b(getParameter(param,2))
{}
int C::getParameter(std::string const& arguments,unsigned int n){
typedef std::map<std::string,std::vector<int> > ParameterCache;
static ParameterCache cache;
ParameterCache::iterator parametersÊche.find(arguments);
if(parameters=Êche.end()){
std::istringstream in(arguments);
std::vector<int> parsedArgs;
while(not(in.eof())){
int argument;
in>>argument;
parsedArgs.push_back(argument);
}
cache[arguments]=parsedArgs;
parametersÊche.find(arguments);
}
if(parameters->second.size()<=n){
throw Error("Too few arguments");
}
return(parameters->second[n]);
}
int main(void){
C c0("0 1 2 3");
C c1("10 11 12 13");
std::cout<<"c0: "<<c0.getA()<<" "<<c0.getB()<<std::endl;
std::cout<<"c1: "<<c1.getA()<<" "<<c1.getB()<<std::endl;
return(0);
}
/*
-*- mode: compilation; default-directory:
"~/src/miscellaneous/tests-c++/" -*-
Compilation started at Sun Apr 13 15:38:52
g++ -o const-member const-member.c++ && ./const-member
c0: 1 2
c1: 11 12
Compilation finished at Sun Apr 13 15:38:57
*/
C'est une très belle solution mais après réflexion, j'ai l'impression que
je sors un tank pour écraser 2 mouches.
C'est une très belle solution mais après réflexion, j'ai l'impression que
je sors un tank pour écraser 2 mouches.
C'est une très belle solution mais après réflexion, j'ai l'impression que
je sors un tank pour écraser 2 mouches.