Rendre une fonction dépendante d'une variable en c++
wella_salwa Messages postés 41 Date d'inscription Statut Membre Dernière intervention -
dans mon algo, j'ai une action windowincrease présentée par la fonction ci dessous, je veux que cette fonction soit dépendante d'un état qui est une variable i, c'est-à-dire windowincrease(i) qui varie selon i.
comment faire en c++
voici mon code :
void
ConsumerPcon::WindowIncrease()
{
if (m_ccAlgorithm == CcAlgorithm::AIMD) {
if (m_window < m_ssthresh) {
m_window += 1.0;
}
else {
m_window += (1.0 / m_window);
}
}
else if (m_ccAlgorithm == CcAlgorithm::CUBIC) {
CubicIncrease();
}
else if (m_ccAlgorithm == CcAlgorithm::BIC) {
BicIncrease();
}
else {
BOOST_ASSERT_MSG(false, "Unknown CC Algorithm");
}
NS_LOG_DEBUG("Window size increased to " << m_window);
}
- Rendre une fonction dépendante d'une variable en c++
- Fonction si et - Guide
- Liste déroulante dépendante excel - Guide
- Comment rendre un fichier moins lourd - Guide
- Une erreur pouvant rendre powerpoint instable s'est produite - Forum WiFi
- Excel remplir automatiquement une cellule en fonction d'une autre ✓ - Forum Excel
2 réponses
Salut wella_salwa,
Ce que tu postes n'est pas un algorithme, c'est un extrait de code source en C++.
Il s'agit de l'implémentation de la méthode WindowIncrease() de la classe ConsumerPcon et il semblerait que "ton" code vienne de ce fichier ndn-consumer-pcon.cpp pour une classe décrite dans cet entête ndn-consumer-pcon.hpp :
https://github.com/6th-ndn-hackathon/congestion-control/blob/master/apps/ndn-consumer-pcon.cpp#L110
https://github.com/6th-ndn-hackathon/congestion-control/blob/master/apps/ndn-consumer-pcon.hpp#L39
Sais-tu ce qu'est le polymorphisme en C++ ?
oui je sais , je suis entrain de simuler une topologie sur NS-3
je n'ai pas une idée sur le " polymorphisme "
Donc, l'implémentation de la méthode WindowIncrease() de la classe ConsumerPcon est dans ce fichier ndn-consumer-pcon.cpp pour une classe décrite dans cet entête ndn-consumer-pcon.hpp :
https://github.com/6th-ndn-hackathon/congestion-control/blob/master/apps/ndn-consumer-pcon.cpp#L110
https://github.com/6th-ndn-hackathon/congestion-control/blob/master/apps/ndn-consumer-pcon.hpp#L39
Cette implémentation ne permet pas le passage de paramètres.
Comme le C++ supporte le polymorphisme, tu peux insérer dans la description de la classe ConsumerPcon de l'entête ndn-consumer-pcon.hpp une nouvelle méthode void WindowIncrease(int i); (en supposant que que i soit un int)
class ConsumerPCON : public ConsumerWindow {
public:
static TypeId
GetTypeId();
/**
* \brief Default constructor
*/
ConsumerPCON() :
CC_ALGORITHM {boost::to_upper_copy(getEnvVar("SCEN_NAME"))}
{
assert(!CC_ALGORITHM.empty());
std::cout << "Started Consumer PCON, Algorithm: " << CC_ALGORITHM << "\n";
ConsumerWindow();
}
// From App
virtual void
OnData(shared_ptr<const Data> contentObject) override;
virtual void
OnTimeout(uint32_t sequenceNumber) override;
// virtual void
// WillSendOutInterest(uint32_t sequenceNumber);
private:
void windowDecrease();
void windowIncrease();
void windowIncrease(int i);
void
cubicIncrease();
(...)
et écrire dans ndn-consumer-pcon.cpp l'implémentation de cette méthode avec cette nouvelle signature, sans toucher à la précédente (crée une nouvelle "fonction" portant le même nom, mais supportant le passage de ce paramètre) :
void ConsumerPCON::windowIncrease()
{
if (CC_ALGORITHM == "AIMD") {
if (m_window < m_sstresh) {
m_window = m_window + 1.0;
}
else {
m_window += (1.0 / m_window);
}
}
else if (CC_ALGORITHM == "CUBIC") {
cubicIncrease();
}
else if (CC_ALGORITHM == "BIC") {
bicIncrease();
}
else {
assert((false) && "Wrong CC Algorithm!");
}
}
void ConsumerPCON::windowIncrease(int i)
{
// TODO: écrire la version modifiée de cette méthode devant s'exécuter
// lorsqu'ellest appelée avec un int passé en paramètre
}
Lorsque cette méthode WindowIncrease() sera appelée sans paramètres par le code existant, c'est le code d'origine qui s'exécutera.
Lorsque cette méthode WindowIncrease() sera appelée avec un int passé en paramètre, c'est le code de ta nouvelle méthode qui sera exécuté.