// GuardedArray
// - A wrapper class for C++ arrays to make array access safe.
//   Specifically, initialization is guaranteed, and assertions are
//   in place to detect array index out of bound errors in array member
//   accesses.
//

class GuardedArray {
public:
  //
  // Constructor
  //
  // Purpose: Initializes array elements to zeros
  // Argument(s): N/A
  // Side Effect: All array elements are initialized to zero.
  // Return: N/A
  //

  GuardedArray();

  //
  // Constructor
  //
  // Purpose: Initializes all array elements to a given value.
  // Argument(s):
  //  x : value to which array elements should be initialized.
  // Side Effect: All array elements are initialized to x.
  // Return: N/A
  //

  GuardedArray(ItemType x);

GuardedArray::GuardedArray() {
  for (unsigned i = 0; i < MAX_LENGTH; i++)
    array[i] = 0;
}

GuardedArray::GuardedArray(ItemType x) {
  for (unsigned i = 0; i < MAX_LENGTH; i++)
    array[i] = x;

// ManagedArray
// - A wrapper class for C++ arrays to facilitate insertion and removal of
//   array elements.
// - Every instance of ManagedArray has a size that can be increased
//   until the maximum capacity MAX_LENGTH is reached.
//

class ManagedArray {
public:
  //
  // Constructor
  //
  // Purpose: Initializes array to have zero size.
  // Argument(s): N/A
  // Side Effect: The array is initialized to be empty.
  // Return: N/A
  //

  ManagedArray();

  //
  // Constructor
  //
  // Purpose: Initializes array to a given size.  All array elements
  //          are initialized to zero.
  // Argument(s):
  //  N : size of array
  // Precondition: N <= MAX_LENGTH
  // Side Effect: The array is initialized to contain N occurrences
  //              of the number zero.
  // Return: N/A
  //

  ManagedArray(unsigned N);

  //
  // Constructor
  //
  // Purpose: Initializes array to a given size.  All array elements
  //          are initialized to x.
  // Argument(s):
  //  N : size of array
  //  x : initial value of array elements
  // Precondition: N <= MAX_LENGTH
  // Side Effect: The array is initialized to contain N occurrences
  //              of x.
  // Return: N/A
  //

  ManagedArray(unsigned N, ItemType x);

  // more function prototypes are there but i'm not confused about them

ManagedArray::ManagedArray() : array() {
  count = 0;
}

ManagedArray::ManagedArray(unsigned N) : array() {
  assert(N <= MAX_LENGTH);
  count = N;
}

ManagedArray::ManagedArray(unsigned N, ItemType x) : array(x) {
  assert(N <= MAX_LENGTH);
  count = N;
}

class Cat              //start of class declaration
{
public:      //the following functions and variables may be accessed anywhere 
  Cat();               //basic constructor
  Cat(int age);      //overloaded constructor
  void Speak();     //a function in this class
  void setAge(int age);
  int getAge();     

private:   //the following functions and variables may be accessed only from
             //objects of this class 
  int myAge;
};                      //end of class declaration

//defining the Cat functions
Cat::Cat()          //class::function(arguments) 
{
  myAge = 0;
}

Cat::Cat(int age) //overloading the constructor to set the cat's age
{
  myAge = age;
}

void Cat::Speak()
{
  std::cout << "Meow.\n";  //an example function of the class
}

Cat::setAge(int age)
{
  myAge = age;
}


int Cat::getAge()
{
  return myAge;           //an accessor function, so other parts of the program
}                              //can get the age

#include <iostream>
#include <stdlib.h>

int main()
{
  Cat Fluffy();
  std::cout << "Fluffy is " << Fluffy.getAge() << " years old.\n";
  Fluffy.setAge(5);
  std::cout << "Fluffy is now " << Fluffy.getAge() << " years old.\n";
  Fluffy.Speak();

  Cat Bob(3);  //ok, maybe Bob isn't exactly a cat's name.  oh, well...
  std::cout << "Bob is " << Bob.getAge() << " years old.";
  Bob.setAge(6);
  std::cout << "Bob is now " << Bob.getAge() << " years old.";
  Bob.Speak();
}

class A { 
private: 
        int m_value; 
public: 
        A(); 


}; 


A::A() : m_value(0) 
{ 


} 

A::A() 
{ 
        m_value = 0; 


} 

class A { 
private: 
        const int m_value; 
public: 
        A(); 


}; 

A::A() 
{ 
        m_value = 0; 


} 

A::A() : m_value(0) 
{ 


} 

class A { 
private: 
        int m_a; 
public: 
        A(int a); 


}; 


A::A(int a) 
        : m_a(a) 
{ 


} 


class B : public A { 
private: 
        int m_b; 
        int m_c; 
public: 
        B(int b); 


}; 


B::B(int b) 
        : A(b), m_b(b+1), m_c(b+2) 
{ 


}

class Foo 
{ 
    Foo(int X, int Y, int Z); 


}; 

class Bar : public Foo 
{ 
    Bar() : Foo(2, 6, 2) {}; 


};