Thread: Abstract Base Class and References

Ok given a class that is abstract due to a pure virtual function you can not have an instance of that class. However you can have a pointer of that type. Now that I'm cool with. What he is trying to say is that you can not have a reference of that type either. This is what I have a problem with. So I decided to test it out:

base.h:

Code:

#ifndef MYBASE_H_
#define MYBASE_H_
#include <iostream>
class mybase {
  int x;
  int y;
  public:
    inline mybase() : x(0), y(0) {}
    virtual ~mybase() {}

    virtual void sayhi() = 0;

    friend std::ostream & operator << (std::ostream &, const mybase &);
};
#endif

base.cpp

Code:

#include <iostream>
#include "base.h"
std::ostream & operator << (std::ostream &out, const mybase &par)
{
  return out<<"Base object: "<< par.x << " " << par.y << endl;
}

dir.h

Code:

#ifndef DIR_H_
#define DIR_H_
#include "base.h"

class dir : public mybase
{
  int z;
  public:
    dir () : z(10) {}
    inline dir operator + () { return *this; }
    virtual void sayhi() { cout<<"Hello"; }
};

#endif

main.cpp

Code:

#include "dir.h"

int main()
{
  dir mydir;
  cout<<mydir<<endl;
  mydir.sayhi();
  cout<<mydir<<endl;
}

Note: Yes I know I forgot some namespaces on cout and endl.

Ok now this compiled and ran as I expected with g++ with the options: -Wall -ansi -pedantic -g

Now this seems to me to indicate that you can have a reference to an abstract class.

Anyone care to comment? (Heres looking at you Sang-drax )

Mostly I need to know if there is some flaw in my test code that is allowing me to do something I'm not suppose to do and/or I'm just misinterpting what I see

Originally Posted by Thantos

What he is trying to say is that you can not have a reference of that type either.

This is from ISO C++ standard:

"An abstract class is a class that can be used only as
a base class of some other class; no objects of an abstract class
can be created except as sub-objects of a class derived from it.
A class is abstract if it has at least one pure virtual function.
[Note: such a function might be inherited: see below. ]
A virtual function is specified pure by using a pure-specifier
in the function declaration in the class declaration.
A pure virtual function need be defined only if explicitly
called with the qualified-id syntax."

Code:

class point { /* ... */ };
class shape {                   //  abstract class
    point center;
    //  ...
public:
    point where() { return center; }
    void move(point p) { center=p; draw(); }
    virtual void rotate(int) = 0;       //  pure virtual
    virtual void draw() = 0;            //  pure virtual
    //  ...
};

"An abstract class shall not be used as a parameter type, as
a function return type, or as the type of an explicit conversion.
Pointers and references to an abstract class can be declared. "
Example:

Code:

shape x;                        //  error: object of abstract class
shape* p;                       //  OK
shape f();                      //  error
void g(shape);                  //  error
shape& h(shape&);               //  OK

What is the section you quoted from the ISO Standard?

NM was able to find a draft copy of the standard.

He is the teacher of the C++ OOP class I'm taking
I tutor Procedural C (with a little bit of C++)

Well I sent him an email earlier with a link to a webpage with a draft copy of the standard, along with a quote from BS on why something like i = i++ + i++; is undefined. Hopefully he'll accept it and change his lectures (and hopfully the the fugly header we have to use for our next project)

Ah yes I remember that thread. I piped up during that part of the lecture and explained what the standard said, though when it came time for the test I gave him the answer he wanted.

I don't remember the exact year of the standard but '98 sounds right. He said he first year of teaching was '00 and he hasn't worked the industry between getting his masters and starting teaching. Hmmm I guess I'll run to kinko's and have a copy of the standard made with a pretty bow on it for him once I buy it

Originally Posted by Thantos

I don't remember the exact year of the standard but '98 sounds right.

Work on the ANSI/ISO C++ standard began in 1990. The committee issued some interim working papers in the following years. In April 1995 it released a Committee Draft (CD) for public comment. In December 1996 it released a second version (CD2) for further public review. These documents not only refined the description of existing C++ features but also extended the language with exceptions, RTTI, templates, and the Standard Template Library. The final International Standard (ISO/IEC 14882:1998) was adopted in 1998 by the ISO, IEC (International Electrotechnical Committee), and ANSI.
The ANSI/ISO C++ standard additionally draws upon the ANSI C standard, because C++ is supposed to be, as far as possible, a superset of C. That means any valid C program ideally should also be a valid C++ program. There are a few differences between ANSI C and the corresponding rules for C++, but they are minor. Indeed, ANSI C incorporates some features first introduced in C++, such as function prototyping and the const type qualifier.

Prior to the emergence of ANSI C, the C community followed a de facto standard based on the book The C Programming Language, by Kernighan and Ritchie (Addison-Wesley Publishing Company Reading, MA. 1978). This standard often was termed K&R C; with the emergence of ANSI C, the simpler K&R C now sometimes is called classic C.

The ANSI C standard not only defines the C language, it also defines a standard C library that ANSI C implementations must support. C++ also uses that library; this book will refer to it as the standard C library or the standard library. In addition, the ANSI/ISO C++ standard provides a standard library of C++ classes.

More recently, the C standard has been revised; the new standard, sometimes called C99, was adopted by ISO in 1999 and ANSI in 2000. The standard adds some features to C, such as a new integer type, that some C++ compilers support. Although not part of the current C++ standard, these features may become part of the next C++ standard.