Newsgroup: it.comp.lang.c++
Titolo: ??? const, [] e altri dubbi ???

*******************************************************************************
Interpretando il listanto sottostante (un include dell GAlib, una libreria di
algoritmi genetici reperibile in 
ftp://lancet.mit.edu
) mi sono imbattuto in
alcuni casi sintattici che non sono riuscito a capire. Qualcuno mi puo'
aiutare? Ecco di cosa si tratta:
1 - Utilizzo della parola chiave const. La const viene utilizzata in tre casi:
    a) Riporto di seguito i primi due casi, cioe' nella dichiarazione
       dei parametri e dopo l'elenco parametri, prima di {........}
 
    int equal(const GAArray<T> &b, unsigned int dest, unsigned int src,
    unsigned int length) const {
      // corpo programma
    }
    b) Un altro caso e' presente quando si specifica il tipo restituito
       da una funzione
    const T & operator[](unsigned int i) const {return a[i];}
2 - Cosa significa esattamente l'operatore [], visto che viene usato,
    oltre che nella definizione di una array di dimensione indefinita,
    anche in istruzioni delete del tipo
        T *a;
	a=new T[100];
	delete [] a;
3 - Cosa significa questa scrittura, in particolare l'utilizzo
    delle parentesi rotonde?
        return new GAArray<T>(*this);}
4 - perche' qui operator compare prima del tipo?
        operator const T * () const {return a;}
************************************************************************
 
// $Header: /usr/people/mbwall/src/galib/ga/RCS/GAArray.h,v 1.1 1996/11/13 01:36:31 mbwall Exp mbwall $
/* ----------------------------------------------------------------------------
  arraytmpl.h
  mbwall 22apr95
  Copyright 1995 Massachusetts Institute of Technology
 DESCRIPTION:
  This defines the array base class.
---------------------------------------------------------------------------- */
#ifndef _ga_arraytmpl_h_
#define _ga_arraytmpl_h_
/* ----------------------------------------------------------------------------
This can be used only on objects that have a public operator= defined (because
of the resize).
Must have a creation operator defined that takes no args
must have operator == and operator != defined
We don't do any over-allocation, so resizing can be expensive.
No error checking on the copy, so don't walk over end of array!
*** should do specialization for simple types that does memcpy rather than loop
---------------------------------------------------------------------------- */
template <class T>
class GAArray {
public:
  GAArray(unsigned int s) : sz(s), a(sz ? new T[sz] : 0){}
  GAArray(const GAArray<T> & orig){sz=0; a=(T *)0; copy(orig);}
  GAArray<T> & operator=(const GAArray<T> & orig){copy(orig); return *this;}
  GAArray<T> & operator=(const T array []) // no err checks!
    {for(unsigned int i=0; i<sz; i++) a[i] = *(array+i); return *this;}
  virtual ~GAArray(){delete [] a;}
  GAArray<T> * clone(){return new GAArray<T>(*this);}
  operator const T * () const {return a;}
  operator T * () {return a;}
  const T & operator[](unsigned int i) const {return a[i];}
  T & operator[](unsigned int i) {return a[i];}
  void copy(const GAArray<T> & orig){
    size(
orig.sz
);
    for(unsigned int i=0; i<sz; i++)
      a[i] = orig.a[i];
  }
  void copy(const GAArray<T> & orig, unsigned int dest,
	    unsigned int src, unsigned int length){
    for(unsigned int i=0; i<length; i++) a[dest+i] = orig.a[src+i];
  }
  void move(unsigned int dest, unsigned int src, unsigned int length){
    if(src > dest)
      for(unsigned int i=0; i<length; i++) a[dest+i] = a[src+i];
    else if(src < dest)
      for(unsigned int i=length-1; i!=0; i--) a[dest+i] = a[src+i];
  }
  void swap(unsigned int i, unsigned int j){T tmp=a[j]; a[j]=a[i]; a[i]=tmp;}
  int size() const {return sz;}
  int size(unsigned int n){
    if(n == sz) return sz;
    T * tmp = (n ? new T[n] : 0);
    for(int i=((n < sz) ? n-1 : sz-1); i>=0; i--) tmp[i] = a[i];
    delete [] a;
    a = tmp;
    return sz=n;
  }
  int equal(const GAArray<T> & b,
	    unsigned int dest, unsigned int src, unsigned int length) const {
    for(unsigned int i=0; i<length; i++)
      if(a[dest+i] != b.a[src+i]) return 0;
    return 1;
  }
protected:
  unsigned int sz;		// number of elements
  T * a;			// the contents of the array
};
template <class T> int 
operator==(const GAArray<T> & a, const GAArray<T> & b){
  if(a.size() != b.size()) return 0;
  return a.equal(b,0,0,
a.sz
);
}
template <class T> int 
operator!=(const GAArray<T> & a, const GAArray<T> & b){
  if(a.size() != b.size()) return 1;
  return a.equal(b,0,0,
a.sz
) ? 0 : 1;
}
#endif
-- 

 ... omissis ...
---
Se non sono stato abbastanza chiaro, mi trovi sempre qui.
Ciao,
Angelo.

        operator const T * () const {return a;}
La keyword "operator" appare per indicare che stiamo
definendo un operatore; 'operator nomediuntipo' e`, in
particolare, l'operatore di conversione implicita -- se
in una data espressione ho un oggetto di questa classe
[anche costante, poiche` questa funzione membro e`
definita const -- e` quella const che appare fra la
chiusa parentesi e l'aperta graffa], e sarebbe invece 
richiesto un "const T*", viene invocata implicitamente
questa funzione-membro per convertire.
Da usare "CON LE MOLLE", perche`, fra overload,
conversori come questo, e costruttori con un solo
argomento non dichiarati "explicit" (che sono anch'essi
"conversori", ma "nell'altro senso"), non ci vuol nulla
per creare situazioni di ambiguita`, e, peggio ancora,
situazioni che IL COMPILATORE non considera per
nulla ambigue (applicando le sue complicate ma precise
regole di risoluzione overload, arriva a una soluzione
ottimale univoca), ma IL PROGRAMMATORE non
capisce (per cui la sequenza di conversioni e overload
utilizzata NON E` quella che il programmatore crede).
Il migliore testo per chiarire questi e tanti altri dubbi e
problemi sul moderno C++ e` Lippman e Lajoie, C++
Primer 3rd edition, Addison-Wesley; ma anche B.
Stroustrup, The C++ Programming Language 3rd
edition, Addison-Wesley, se uno "il linguaggio ad un
livello elementare" lo conosce gia` (Stroustrup e`
brillante, ma secondo me Lippman e Lajoie sono
piu` chiari, precisi, dettagliati, e didattici).
Alex