Thread: moving from c to c++

Hi, I've been programming in c for a while, and have started reading about c++. Having never done any OO programming before, I'm trying to get my head around objects and classes.

I've read that a class is like a blueprint for something, and that an object is an instance of this 'something'. I understand that a class has 2 aspects, fields and methods, and I can understand the fields aspect - that a class has fields, and an object (instance of the class) has a particular set of values for these fields - but not the methods.

If we have the class of dogs, or the class of cars, then essentially we have a c structure with fields describing characteristics of cars/dogs right? E.g. this would be something like:

Code:

class car{
  char registration[];
  char colour[];
  char model[];
  int age;
  int milage;  
}

so what are methods, and where do they come into it? How do they compare to functions and structures in c?

Thanks

A method is a function which has implicit access to the fields of the object instance. That's really all there is to it.

In C, you might have this:

Code:

struct foo
{
    int a;
    char *b;
};

foo_do_something(struct foo *obj)
{
    obj->a = 0;
    obj->b = "Hello, world!\n";
}

Whereas C++ you might have:

Code:

class foo
{
    int a;
    char *b;

public:
    do_something();
};

foo::do_something()
{
    a = 0;
    b = "Hello, world!\n";
}

What member functions you need for a car class (or a dog class) depends entirely on what you actually need to do with the class.

In general, you obviously need to do the same work whether it is in an object oriented programming language (such as C++) or a procedural language like C.

The difference is that you do the work WITH a class member, rather than as a function that takes an explicit parameter of some sort.

So, for example, if we want to draw a rectangle in C:

Code:

void drawRectangle(int x, int y, int w, int h)
{
   line(x, y, x+w, y);    // Top horizontal line. 
   line(x+w, y, x+w, y+h);   // Right side vertical line. 
   line(x+w, y+h, x, y+h);   // Bottom horizontal line
   line(x, y+h, x, y);     // Left side vertical line
}

int main()
{
    drawRectangle(100, 100, 300, 200);
}

In C++, the same thing could, perhaps be done by having a rectangle class:

Code:

class rectangle
{
   int x, y, w, h;
public:
   rectangle(int ax, int ay, int aw, int ah) : x(ax), y(ay), w(aw), h(aw)  {};
   void draw();
} 

void rectangle::draw()
{
   line(x, y, x+w, y);    // Top horizontal line. 
   line(x+w, y, x+w, y+h);   // Right side vertical line. 
   line(x+w, y+h, x, y+h);   // Bottom horizontal line
   line(x, y+h, x, y);     // Left side vertical line
}

int main()
{
    rectangle r(100, 100, 300, 200);
    r.draw();
}

So as you can see, in the object oriented world, we first construct a rectangle, then draw it, whereas in the C world, we call a function that knows how to draw a rectangle - both drawing functions do the exact same thing, but one uses the implicit knowledge of the rectangle size given in the constructor, the other the values given by the calling code.

It's probably not a very good example, but...

--
Mats

Ok thanks, that's easy enough

matsp, that's a really good example thanks. Also, I forgot to ask my other question: What's the point of using cin and cout instead of printf etc to output to a terminal or file? There must be some reason why they changed the I/O functions from c, but why?

cin and cout works COMPLETELY different from printf/scanf. We are getting to a fairly advanced part of C++ to describe HOW you do this, but the essence of it is that you can do use cin and cout to read "objects" from stdin or write "objects" to stdout.

For example, if we have the rectangle class from above defined with the right bits of output helper functions, we can do this:

Code:

int main()
{
   rectangle r(100,100, 200, 300);
   cout << r;
}

we could, perhaps, get output like this:

Code:

rectangle: x=100, y=100, w=200, h=200

This works by defining a operator<<(ostream &, rectangle) function [it may also be a member function of the rectangle class, in which case the rectangle parameter is implicit to the function, rather than written out] - as I said, it's quite advanced topic, so I'm not going to go into detail, it would just cause your brain to hurt! You'll get there in chapters later on in your book.

--
Mats

Thanks both thats alot clearer now