Compteur de référence

Considérons les données et opérations

const int M = 1000; Vector<float>  a(M), b(M), c(M), d(M); 
d = a + b * c ;

A chaque opération un résultat intermédiaire est stocké puis détruit, ce qui peut être couteux. Il existe des techniques pour diminuer le nombre de ces opérations inutiles. Notre expérience nous a montré que le temps d'exécution de ces opérations est inférieur à 10% du temps total pour les éléments finis, c'est en plus une source d'erreur, mais il faut connaitre ce problème et ses solutions. Par exemple,

class Vector: public A<VectnN> { public:
//----------------------------------
	int *w;
	int& refcount () {return *w;}
	void dec ();
	void clone();
  ~Vector ();
  Vector (int ssize=0);
  Vector ( const Vector& v );
  const Vector& operator = ( const Vector& v);
  const Vector& operator = ( const base r);
  vbase& operator [] ( int i) const { assert((i>=0)&&(i<size)); return cc[i]; }
  friend Vector operator + (const Vector& , const Vector& );
};

void Vector::dec()
{//  cout << "Reference count:" << refcount() << endl;
  if (!--(refcount()))
  { delete [] cc;  cc = 0; size = 0; delete w;}
}

void Vector::clone()
{ if (refcount() == 1) return;
  refcount()--;
  vbase *u = new vbase[size]; assert(u);
  for (int i = 0; i < size; i++) u[i] = cc[i];
  cc = u;
  refcount() = 1;
}

Vector::~Vector () {	dec();}

Vector::Vector (int ssize=0): A<vbase> (ssize) 
{ 	w = new int;  refcount()=1; }

Vector::Vector ( const Vector& v )
{ 	w = v.w; size = v.size; cc = v.cc; refcount()++;}

const Vector& Vector::operator = ( const base r)
{  clone();
	  for (int i=0; i<size;i++) cc[i] = r; 
	  return *this;  
}

const Vector& Vector::operator = ( const Vector& v)
{ assert(v.size==size); 
 	if(cc !=v.cc)
 	{  dec(); 
 		  w = v.w; cc = v.cc; size = v.size; 
 		  refcount()++;
 	}
 	return *this;  
}