THMMY.gr

Ο unsigned int έχει μέγεθος 32bits. Επομένως επιτρέπεται να του κάνεις shift μέχρι 31 θέσεις. Αν του πεις θέλω 32 shift το αποτέλεσμα θα είναι απλώς ότι του κάτσει.

Ο compiler έτσι όπως είναι γραμμένο δεν θα βγάλει error. Αν όμως γράψεις unsigned int integer=value>>32; θα σου πει πως δεν επιτρέπεται τόσο μεγάλο shift.

class XMLParser
{
public:
   XMLParser()
   {
      read();
   }

   virtual void readImpl() = 0;

   void read()
   {
      //bla bla
      readImpl();
   }
};

class MyParser: public XMLParser()
{
public:
   MyParser(): XMLParser()
   {

   }

    void readImpl()
    {
      cout <<" Hi from MyParser" << endl;
    }
};

int main()
{
   MyParser* parser = new MyParser();
   return 0;
}

#include <iostream>

using namespace std;

class A
{
public:
   virtual void callImpl() = 0;

   void call()
   {
      callImpl();
   }
};

class B: public A
{
public:
   void callImpl()
   {
      cout << "Hi from B" << endl;
   }
};

int main()
{
   A* a = new B();

   a->call();
}

Αυτό είναι εντελώς διαφορετικό.... Ουσιαστικά επειδή η Α είναι abstract κλάση ο Α* που έχεις δείχνει στο αντικείμενο τύπου Β και καλείς αντικείμενα-υλοποιήσεις τύπου Β. Αντίθετα στην άλλη περίπτωση το καλείς από τον constructor. ΔΕΝ υπάρχει ακόμη το αντικείμενο Β αφού δεν έχει ολοκληρωθεί η κλήση του constuctor του. Άρα καλείς την readImpl στο scope του Α στο οποίο η readImpl είναι pure virtual και δε μπορεί να κληθεί.

public class MainClass {

   public abstract static class A
   {
      public A()
      {
         run();
      }
      
      public void run()
      {
         runImpl();
      }
      
      public abstract void runImpl();
   }
   
   public static class B extends A
   {

      public B()
      {
         super();
      }
      
      @Override
      public void runImpl()
      {
         System.out.println("Hi from B");
      }
      
   }
   
   public static void main(String[] args) {
      A a = new B();
   }

}

template<class T> class MemoryPool
{
private:

   /**
    * The chunk of memory that is allocated
    * whenever the pool gets full. Optimal
    * solution would need increment and decrement
    * of the size according to the rate at which
    * the application requests or releases resources.
    */
   static const int BLOCK_SIZE = 1000;

   /*
    * Points to the head of the free objects block.
    */
   static T* headOfFreeList;

   /*
    * Specifies the next object in the block.
    */
   T* next;

   static MutexLock* lock;


public:

   /*
    * Acquires a preallocated space from the memory pool.
    */
   static void* operator new(size_t size)
   {
      if(lock == 0)
         lock = new MutexLock();

      lock->lock();

      if (size != sizeof(T))
         return ::operator new(size);

      T* p = headOfFreeList;

      if (p)
      {
         headOfFreeList = p->next;
      }
      else
      {
         T* newBlock = static_cast<T*>(::operator new(
               BLOCK_SIZE * sizeof(T)));

         for (int i = 0; i < BLOCK_SIZE - 1; ++i)
         {
            newBlock[\i].next = &newBlock[i + 1];
         }

         newBlock[ BLOCK_SIZE ].next = 0;

         p = newBlock;

         headOfFreeList = &newBlock[1];
      }
      lock->unlock();
      return p;
   }

   /*
    * Releases a space to the preallocated memory pool.
    */
   static void operator delete(void *deadObject, size_t size)
   {
      lock->lock();
      if (deadObject == 0)
         return;

      if (size != sizeof(T))
      {
         ::operator delete(deadObject);
         return;
      }

      T* carcass = static_cast<T*>(deadObject);

      carcass->next = headOfFreeList;

      headOfFreeList = carcass;
      lock->unlock();
   }
};

template< class T > MutexLock* MemoryPool<T>::lock = 0;
template< class T > T* MemoryPool<T>::headOfFreeList = 0;