[RISOLTO] 1 << ( sizeof(num_type) * 8 )

[giuscri]

Ciao ragazzi! Sto leggendo un programma scritto dal mio professore e ho trovato qualcosa di veramente poco chiaro:

#include <iostream>

#include <ctime> // clock_gettime() nanosleep()
#include <cstdlib> // srand() rand()

class lottery
{
  public:

    typedef unsigned short num_type;

    lottery(unsigned long long i_max_num = (1<<(sizeof(num_type)*8))) // Constructor
     {
      timespec current_time;
      clock_gettime(CLOCK_REALTIME,&current_time); // If it fails we take 
                                                   // random initial value;
// ...

Come devo interpretare quel

1<<(sizeof(num_type)*8))

?

Tra l'altro mi aspetterei che $"lottery(unsigned long long)"$ sia un costruttore con argomenti passati dall'utente. Qualche riga più sotto infatti trovo

lottery::num_type my_guess;
lottery easy_lottery(3);

Ma quel $3$ non so assolutamente come possa essere passato al costruttore dato che

unsigned long long i_max_num = (1<<(sizeof(num_type)*8))

mi sa di un'assegnazione che avviene sempre nello stesso modo -i.e. il $3$ dove lo metto?

Se dovessi essere stato poco chiaro, nello spoiler il programma completo:

#include <iostream>

#include <ctime> // clock_gettime() nanosleep()
#include <cstdlib> // srand() rand()

class lottery
{
  public:

    typedef unsigned short num_type;

    lottery(unsigned long long i_max_num = (1<<(sizeof(num_type)*8))) // Constructor
     {
      timespec current_time;
      clock_gettime(CLOCK_REALTIME,&current_time); // If it fails we take 
                                                   // random initial value;
      srand(current_time.tv_nsec);
      m_max_num = i_max_num;
      m_winning_number = rand()%m_max_num;
      m_prize = attempt_cost;
      m_somebody_won = false;
     }

    ~lottery() // Destructor
     {
      if (!m_somebody_won)
       {
        std::cout << "Nobody won: the prize is now " << m_prize 
                  << " Euros!" << std::endl;
       }
     }

    bool attempt(num_type m_guess)
     {
      if (!m_somebody_won)
       {
        if (m_guess == m_winning_number)
         {
          m_somebody_won = true;
          return true;
         }
        else m_prize += attempt_cost;
        return false;
       }
      else return false;
     }

    float prize()
     {
      return m_prize;     
     }

    static const float attempt_cost = 1.5;

  private:
    num_type m_winning_number;
    long long m_max_num;
    float m_prize;
    bool m_somebody_won;
};

int main(int argc, char *argv[])
{
  lottery::num_type my_guess;
  lottery easy_lottery(3);

  std::cout << "Please enter your guess. This will cost you "
            << easy_lottery.attempt_cost << " Euros --->";
  std::cin >> my_guess;

  std::cout << "Trying with number " << my_guess << ": ";

  switch(my_guess)
   {
    case 0:
        std::cout << "Zero is nothing... Not even a valid number";
        break;
    case 1:
        std::cout << "You picked number one - L'Italia";
        break;
    case 2:
        std::cout << "You picked number two - La bambina";
        break;
    case 3:
        std::cout << "You picked number three - Il gatto";
        break;
    case 4:
        std::cout << "You picked number four - Il porco - No chance to win";
        break;
    default:
        std::cout << "Ok. If this makes you happy. You are unlikely to win."; 
   }

  std::cout << std::endl << "Now checking... Suspense..." << std::endl;

  bool result = easy_lottery.attempt(my_guess-1); // Make it 1-based.

  timespec suspense;
  suspense.tv_sec = rand()%3;
  suspense.tv_nsec = rand()%1000000000;

  nanosleep(&suspense, 0);

  if (!result) std::cout << "Sorry, you lost." << std::endl;
  else         std::cout << "CONGRATULATIONS! You won " << 
                       easy_lottery.prize() << " Euros!" << std::endl;
  
  int int_result = result;

  std::cout << "The integer value of bool result is: " << int_result 
            << std::endl;

  if (int_result) std::cout << "According to int_result you won." << std::endl;
  else            std::cout << "According to int_result you lost." << std::endl;

  return 0;
}

Grazie!

[claudio862]

In C++ gli argomenti delle funzioni possono avere valori di default.

void f(int a = 3);

...

f(57); // Chiama f() con argomento 57

f(); // Chiama f() con argomento (di default) 3.

Il costruttore è una funzione come le altre (più o meno), quindi "(1<<(sizeof(num_type)*8))" è il valore di default dell'argomento.

L'operatore << sposta i bit dell'argomento a sinistra di n posizioni, dove n è l'argomento a destra. Quindi sposta i bit di 1 (che sono 000...00001) di sizeof(num_type)*8 posizioni a sinistra.

In sostanza, se num_type è grande 16 byte (128 bit) sposta i bit di 1 di 128 posizioni a sinistra. Quindi il valore finale è 10000...000 con 128 zeri. Che è uno più del massimo valore possibile memorizzabile in un num_type (se è unsigned).

In realtà quell'espressione non è completamente portabile, non è detto che un char sia composto da 8 bit (dovresti usare la macro CHAR_BIT definita (mi pare) in cstdef). Inoltre sarebbe meglio usare la classe numeric_limits, che è decisamente più chiara:

#include <limits>

typedef ... num_type;

unsigned long long a = (1<<(sizeof(num_type)*8))

unsigned long long b = std::numeric_limits<num_type>::max() + 1;

[giuscri]

"claudio86":In C++ gli argomenti delle funzioni possono avere valori di default.

void f(int a = 3);

...

f(57); // Chiama f() con argomento 57

f(); // Chiama f() con argomento (di default) 3.

Il costruttore è una funzione come le altre (più o meno), quindi "(1<<(sizeof(num_type)*8))" è il valore di default dell'argomento.

L'operatore << sposta i bit dell'argomento a sinistra di n posizioni, dove n è l'argomento a destra. Quindi sposta i bit di 1 (che sono 000...00001) di sizeof(num_type)*8 posizioni a sinistra.

In sostanza, se num_type è grande 16 byte (128 bit) sposta i bit di 1 di 128 posizioni a sinistra. Quindi il valore finale è 10000...000 con 128 zeri. Che è uno più del massimo valore possibile memorizzabile in un num_type (se è unsigned).

Grande!

"claudio86":In realtà quell'espressione non è completamente portabile, non è detto che un char sia composto da 8 bit (dovresti usare la macro CHAR_BIT definita (mi pare) in cstdef). Inoltre sarebbe meglio usare la classe numeric_limits, che è decisamente più chiara:

#include <limits>

typedef ... num_type;

unsigned long long a = (1<<(sizeof(num_type)*8))

unsigned long long b = std::numeric_limits<num_type>::max() + 1;

Ok, questo cercherò di ricordarmelo.

Grazie mille! Buona giornata!