[C++] Classe: stessa funzione con o senza parametri

[gianvituzzi]

Salve,

mettiamo che ho un metodo di una classe che può essere chiamato con o senza parametri:

classe marameo {
public:
	marameo();
	void print(void);
	void print(std::string);
private:
	std::string szStringa;
}

void marameo::print(void)
{
	szStringa = "stringa di default";
	printf("%s\n", szStringa);
}

void marameo::print(std::string a)
{
	szStringa = a;
	printf("%s\n", szStringa);
}

in questo caso devo scrivere due funzioni distinte per lo stesso metodo usando l'overloading: una che accetta parametri, l'altra no.

Tuttavia le funzioni però fanno la stessa cosa, essendo dello stesso metodo. Ma mi tocca scriverle separate! quindi duplico il codice. Quello che vorrei fare io è che se il metodo è chiamato con dei parametri usi quelli, altrimenti usi dei parametri di default...

ci posso stare a fare due costruttori separati in fondo il codice è poco (solo inizilizzare variabili), ma due funzioni per lo stesso metodo dovrei duplicare il codice e mi risulterebbe moolto inconveniente...spero che C++ offra una soluzione a questo.

grazie

[antotan]

#include <string>
#include <iostream>

class A { 
  public: 
    A(){} 
    void print(std::string mystring = std::string("ciao")){ 
      this->mystring = mystring; 
      std::cout << mystring << std::endl; 
    } 

  private: 
    std::string mystring; 
}; 

int main() { 
  A a; 
  a.print(); 
  a.print("hello"); 
} 

Spero sia quello che cercavi

[gianvituzzi]

menomale, ache se all'ultimo avevo pensato ad una cosa forse un pò bizarra:

void marameo::print(void)
{
	szStringa = "stringa di default";
	_print(szStringa);
}

void marameo::print(std::string a)
{
	szStringa = a;
	_print(szStringa);
}

void marameo::_print(std::string a) // Privata
{
	szStringa = a;
	printf("%s\n", szStringa);
}

ovvero _print è un metodo privato che fa il vero lavoro, le due print servono solo a convogliare i dati o impostarli di default...

[antotan]

Ciao, la tua soluzione va bene, crei due (o più) metodi che faranno da interfaccia per il lavoro che avviene dietro le quinte. Sta a te decidere come procedere. Dipende dalla logica del programma, se è diversa di volta in volta o se è solo una questione di impostare un valore di default. Del tipo, qui:

class Sorter {
  public:
    Sorter(){...}
    void sort(Records& r) {
      if (r.size() < 20) algo_1(r);
      else if (r.size() < 100) algo_2(r);
      ....
}

  private:
    void algo_1(Records& r);
    void algo_2(Records& r);
    .... 

dai come interfaccia all'utente il metodo sort, che sbriga lui il lavoro sporco (la scelta dell'algoritmo più efficiente). Mentre qui:

class WebServer {
  public:
    WebServer(){...}
    void connect(string host, int port = 80) {...}
} 

conviene impostare solo il valore di default, tanto la logica non cambia.
Spero sia chiaro