Newsgroup: it.comp.lang.c++
Titolo: Uso delle funzioni che operano sul vettore di una classe

Io ho una classe del genere:
class Frame {
  vector<int> privimage;
public:
  // tutta una serie di funzioni che operano su privimage
  };
Dovrei realizzare una funzione che lavori su due oggetti di tipo
Frame, in particolare che scandisca i vettori ed esegua delle
operazioni.
Qualcosa del tipo:
for (i=0; i<prova.size(); i++)
  // esegue operazioni
dove prova e' un oggetto di tipo Frame.
Ovviamente cosi' non e' possibile, perche' prova non e' un vettore.
Devo per forza definire in Frame una funzione read_size che mi
restituisca la dimensione del vettore? In modo che io possa poi
scrivere:
for (i=0; i<prova.reade_size(); i++)
  // eccetera eccetera
e devo farlo per ogni funzione che lavori su vector?
Grazie.
Claudio Mantelli
Remove SPAMMERSF*CK from my email address to reply

 Ovviamente cosi' non e' possibile, perche' prova non e' un vettore.
Naturalmente nulla ti impedisce di definire una sua funzione
size() (una inline che delega a privimage.size()) e per futuri
template puo` essere meglio che non darle un altro nome.
Piu` raffinato, definire una classe ausiliaria "frameiterator"
e due metodi begin() e end() in Frame per tornare il primo
e l'uno-dopo-l'ultimo frameiterator di un dato Frame.  Con
questo approccio, hai gia` tutti gli algoritmi di <algorithm>
a tua disposizione.
Alex

a tua disposizione.
Scusa, ma c'e' qualcosa di essenziale che mi sfugge.
Io ho questa classe Frame, che è sostanzialmente costituita da un
vettore di numeri (private) e una serie di funzioni che vi operano
sopra.
class Frame {
  vector<int> privimage;
public:
  // tutta una serie di funzioni che operano su privimage
  };
Devo fare una semplice funzione Subtract, che abbia in input due
oggetti Frame e mi restituisca in output un altro oggetto Frame
ottenuto facendo sostanzialmente la sottrazione cella a cella dei due
vettori.
Possibile che io debba ridefinire un sacco di funzioni per fare una
cosa cosi' semplice?
Se mi limitassi a definire Frame come un vettore, potrei scrivere un
semplicissimo loop:
Frame a,b,c;
for (i=0; int<a.end(); int++)
  c [i] = a[i] - b[i];
Definendo invece Frame come una class, includendo quindi tutte le
funzioni, non lo posso fare.
Eppure ci deve essere qualcosa di altrettanto semplice, altrimenti
l'uso del C++ al posto del C mi farebbe solo perdere tempo, e non mi
sembra possibile.


 funzioni, non lo posso fare.
E perche'?  Basta definire un metodo opportuno.  Questo e' un esempio
minimale (quick&dirty):
MLO@axcdf4 6 $ cat foo.cxx
#include <iostream>
#include <vector>
#include <stdexcept>
#include <algorithm>
#include <functional>
using namespace std;
class Frame {
 private:
  vector<int> _v;
 public:
  Frame(vector<int>::size_type n, const int first=0, const int delta=1);
  ~Frame() {};
  Frame operator + (const Frame &rhs);
  void print(void) {
    copy(_v.begin(), _v.end(), ostream_iterator<int>(cout, " "));
    cout << endl;
  };
};
Frame::Frame(
  vector<int>::size_type n,
  const int first,
  const int delta
) : _v(n) {
  vector<int>::size_type i;
  int value(first);
  for (i=0; i<n; i++) {
    _v[i] = value;
    value += delta;
  }
}
Frame Frame::operator + (
  const Frame &rhs
) {
  if (this->_v.size() != rhs._v.size())
    throw logic_error("Sizes don't match");
  Frame temp(*this);
  transform(temp._v.begin(), temp._v.end(),
            rhs._v.begin(),
            temp._v.begin(),
            plus<int>());
  return temp;
}
int main() {
  Frame f(10,2,4), g(10,1,1);
  Frame s = f+g;
  cout << "f = "; f.print();
  cout << "g = "; g.print();
  cout << "somma = "; s.print();
}
MLO@axcdf4 7 $ KCC -o foo foo.cxx
MLO@axcdf4 8 $ ./foo
f = 2 6 10 14 18 22 26 30 34 38 
g = 1 2 3 4 5 6 7 8 9 10 
somma = 3 8 13 18 23 28 33 38 43 48 
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it

 sembra possibile.
Mi sembra che "l'uso del C++ al posto del C" non abbia nulla a che
vedere con i tuoi problemi; si tratta, se mai, di "l'uso dell'incapsulamento
e dell'information hiding" (C++ non fa altro che offrirti un ampio
sovrainsieme degli strumenti disponibili in C per fare incapsulamento
e information hiding con molta piu` flessibilita`, comodita`, e controlli
a tempo di compilazione sulla correttezza dei tipi).
In un progetto-giocattolo, puo` essere difficile vedere quali vantaggi
discendano dall'incapsulare (e nascondere) informazioni, perche` si
tratta soprattutto di vantaggi che emergono, o in un progetto grande,
o in una _serie_ di progetti (riusabilita`, manutenibilita`,
modificabilita`).
Alex