// ============================================
// Week 9: Classes (II) (p. 8)

class A
{
private:
  static int count;
public:
  A() { A::count++; }
  static int getCount() 
  { return A::count; }
};

int A::count = 0;

int main()
{
  A a1, a2, a3;
  cout << A::getCount() << endl;
    // 3
  return 0;
}






// ============================================
// Week 9: Classes (II) (p. 8)

class A
{
private:
  static int count;
public:
  A() { A::count++; }
  ~A() { A::count--; }
  static int getCount() 
  { return A::count; }
};

int A::count = 0;

int main()
{
  if(true)
    A a1, a2, a3;
  cout << A::getCount() << endl;
    // 0
  return 0;
}







// ============================================
// Week 9: Classes (II) (p. 14)


MyVector cenGrav
  (MyVector v1, MyVector v2, MyVector v3)
{
  // assume that their dimensions are identical
  int n = v1.getN(); 
  int* cen = new int[n];
  for(int i = 0; i < n; i++) 
    cen[i] = v1.getM(i) + v2.getM(i) + v3.getM(i);
  MyVector cog(n, cen); 
  return cog; 
}

MyVector::getN() 
{ return n; }
MyVector::getM(int i) 
{ return m[i]; }
MyVector::MyVector
  (int d, int v[])
{
  n = d;
  for(int i = 0; i < n; i++)
    m[i] = v[i];
}





// ============================================
// Week 9: Classes (II) (p. 15)

MyVector cenGrav(MyVector* v1, MyVector* v2, MyVector* v3)
{
  // assume that their dimensions are identical
  int n = v1->getN(); 
  int* cen = new int[n];
  for(int i = 0; i < n; i++) 
    cen[i] = v1->getM(i) + v2->getM(i) + v3->getM(i);
  MyVector cog(n, cen); 
  return cog; 
}






// ============================================
// Week 9: Classes (II) (p. 16)

MyVector cenGrav(MyVector& v1, MyVector& v2, MyVector& v3)
{
  // assume that their dimensions are identical
  int n = v1.getN(); 
  int* cen = new int[n];
  for(int i = 0; i < n; i++) 
    cen[i] = v1.getM(i) + v2.getM(i) + v3.getM(i);
  MyVector cog(n, cen); 
  return cog; 
}






// ============================================
// Week 9: Classes (II) (p. 18)

class A
{
private:
  int i;
public:
  A() { cout << "A"; }
};
void f(A a1, A a2, A a3)
{
  A a4;
}

int main()
{
  A a1, a2, a3; // AAA
  cout << "\n===\n";
  f(a1, a2, a3); // A
  return 0;
}






// ============================================
// Week 9: Classes (II) (p. 19)

int main()
{
  A a1, a2, a3; // AAA
  cout << "\n===\n¡§;
  A a4 = a1; // nothing!
  return 0;
}





// ============================================
// Week 9: Classes (II) (p. 21)

class A
{
private:
  int i;
public:
  A() { cout << "A"; }
  A(const A& a) { cout << "a"; }
};

void f(A a1, A a2, A a3)
{
  A a4;
}
int main()
{
  A a1, a2, a3; // AAA
  cout << "\n===\n";
  f(a1, a2, a3); // aaaA
  return 0;
}






// ============================================
// Week 9: Classes (II) (p. 23)

MyVector::MyVector(const MyVector& v)
{
  n = v.n;
  m = v.m; // shallow copy
}





// ============================================
// Week 9: Classes (II) (p. 24)

MyVector::MyVector(const MyVector& v)
{
  n = v.n;
  m = new int[n]; // deep copy
  for(int i = 0; i < n; i++)
    m[i] = v.m[i];
}





// ============================================
// Week 9: Classes (II) (p. 29)

void MyVector::print()
{
  cout << "(";
  for(int i = 0; i < this->n - 1; i++)
    cout << this->m[i] << ", ";
  cout << this->m[this->n - 1] << ")\n";
}





// ============================================
// Week 9: Classes (II) (p. 30)

MyVector::MyVector(int n, int m[])
{
  this->n = n;
  for(int i = 0; i < n; i++)
    this->m[i] = m[i];
}






// ============================================
// Week 9: Classes (II) (p. 35)

class MyVector
{
private:
  const int n; 
  int* m; 
public:
  MyVector() : n(0) {};
  MyVector(int dim, int v[]) : n(dim)
  {
    for(int i = 0; i < n; i++)
      m[i] = v[i];    
  }; 
  // ...
};






// ============================================
// Week 9: Classes (II) (p. 36)

class MyVector
{
private:
  const int n; 
  int* m; 
public:
  MyVector();
  MyVector(int dim, int v[]); 
  // ...
};

MyVector::MyVector() : n(0)
{
  m = NULL;
}
MyVector::MyVector(int dim, int v[]) : n(dim)
{
  for(int i = 0; i < n; i++)
    m[i] = v[i];
}