Examples of a C++ wrong code implementation . . Instructor Jeff Zhuk

1. Constructor and Deconstructor

   1.         class starChild
              {
                  private:
                      int veryGood;
                  public:
                      int starChild::starChild() {
                          verygood=1;} // Error -> Constructor cannot
                                       // return a value.
              };
              

      
      

   2.         class C {
                      int x;
                      int y;
                  public:
                      int C ( ); 
                      // This constructor would cause an error because
                      // it has a return type. Constructors must meet 2 
                      // conditions to be valid: no return value and the 
                      // constructor name same as the class name.
                  ...
                  ...
                  ...
              };
              

      
      

   3.         class x         // not a good style, better to Capitalize
              {               // class name !
                  private:
                      int x;  // confusing ! variable name as a class name
                      int y;
                  public:
                      XX(){ };   // compiler error; 
                                 // method is not a constructor 
                                 // It must have a return value.
              }
              

      
      
2. Private, protected and public sections

   1.             class starChild
                  {
                       private:
                          int veryGood = 1; // Cannot be initialized in this manner.
                                            // Must be done via constructor or other
                                            // member function.
                       public:
                           int returnHighIQ();
                       starChild:starChild (startChild);
                      // Error -&bg Constructor cannot take as parameter an object
                      // itself. The correct way to do this would be by making the
                      // parameter a reference (starChild). This would be the dec-
                      // laration for a copy constructor.
      
                        private:
                           int highIQ;
                      };   
                      

      
      

   2.                 class Kathy {
                          public:
                              int (int num);
                              ~Kathy(void);
                              void display();
                          private:
                              char *title;
                              int rec_number;
                          protected:
                              void showError();  // method in protected area - limited access.
                      
                      };
                      ...
                      ...
                      count << "Enter title of CD " << end1;
                      cin >> title >> end1;      // cannot access private member 'title'.
                      count << "Enter CD identification" << end1;
                      cin >> rec_number >> end1; // cannot access private member 'rec_number'.
                      // Both 'title' and 'rec_number' have to be accessed a different way - could 
                      // create a public method that could be called to access private attributes.
                      

      
      

   3.                 class A { // base class
                          protected:
                              int x;
                              ine y;
                          public:
                              void print(int x,int y);
                              void add (int x, int y);
                              void subtr ( int x, int y);
                              A ( );
                              ~A ( );
                      };
      
                      class B: public A { // derived class
                          private:
                              int A;
                              int B;
                          public:
                              void print ( int x, int y);
                              void add ( int x, int y);
                              void substr (int x, int y);
                              B ( );
                              ~B ( );
                      };
      
                      main {
                          A A_type;
                          cout << int x = << A_type << end1;
                          // THis is error because 'x' is only accessable to the class methods.
                          // The correct way would be to invoke the print method: A_type.print(3,4).
                      

      
      

   4.                 class X
                      {
                          private:
                              int x;
                          protected:
                              int y;
                          public:
                              int z;
                              void display (int x, int y, int z);
                          ...
                       main
                       {
                         X ob1;
                          ob1.display(5,8,10); // Runtime error.'x' is a private.     
                          ...
                      

      
      
3. Derived classes

   1.                 class B
                      {
                          private:
                              int x;
                          protected:
                              int y;
                          public:
                              void show(int x, int y);
                      };
                      class D : public B
                      {
                          private:
                              int z;
                          public:
                              void show (int):
                      }
      
                      main ( )
                      {
                      B b_ob;
                      D d_ob;
                      d_od.show (x,y); // runtime error. 'x' is private and not accessable to D.
                      ...
                      

      
      

   2.                 class rock
                      {
                          private:
                              int diamond;
                              int ruby;
                              int amber;
                          public:
                              rock:: rock ( diamond = 1; ruby = 2; amber = 100);
                              showAll ();
                      };
                      class dirt : public rock
                      {
                          private:
                              int sand;
                          public:
                              dirt :: dirt();
                      };
      
                      main ()
                      {
                      dirt t;
                      dirt *ptr_d;
                      ptr_d = &d;
                      ptr_d ->ruby = 5; // Error: ruby is not visible in derived class.
                      ...
                      

      
      
4. Polymorphism

   1.                 class rock
                      {
                          private:
                              int diamond;
                          public:
                              rock::rock();
                          virtual int grindToDirt():
                      };
                      class dirt
                      {
                          private:
                              int sand;
                          public:
                              int grindToDirt():
                      };
                      main ()
                      {
                      rock r;
                      dirt d;
                      dirt *ptr_d;
                      ptr_d = &d;
                      ptr->grindToDirt():
                      ptr_d = &r; // Error: cannot take on the address of base class (not
                                  // without a cast).
                      ...
                      

      
      

   2.                 class Shape {          // assume it's a base class for
                                             // polymorphic usage of area() method in derived
                                             // Circle and Square classes
                          public:
                              float area (); // incorrect - needs keyword "virtual" before
                                             // float in order for subclass to inherit and use 
                                             // polymorphically.
                      };
                      class Circle : public Shape {
                          public:
                              float area(int radius); // incorrect:
                      };                              // must be same prototype
                                                      // as in the base class
      
                      class Square {    // incorrect - derived class must
                                        // have "public Shape" after "class
                                        // Square" to inherit from base class.
                          public :
                              float (area(int height, int width);// incorrect:
                                        // must be same prototype
                                        // as in the base class
                      };
                      

      
      

   3.                 class B
                      {
                          protected:
                              char *name;
                              char * address;
                              int age;
                          public:
                              int getAge(int);
                              void Show();
                      };
      
                      class D : public B
                      {
                          protected:
                              int grade;
                          public:
                              int getGrade();
                              void Show();
                      };
      
                      main ()
                      {
                          B *b;
                          D *d;
                          b->Show(); // runtime error: need virtual keyword.
                          d->Show();
                          ...