getting to know classes in C++ better [closed] - c++

Question

It's difficult to tell what is being asked here. This question is ambiguous, vague, incomplete, overly broad, or rhetorical and cannot be reasonably answered in its current form. For help clarifying this question so that it can be reopened, visit the help center.
Closed 10 years ago.
I have taken several classes now in C++ and a little bit of python. And a common thing that keeps coming up is my failure to really understand whats going on when you are creating a class. I was wondering if someone could either explain the specifics as far as classes in C++ are concerned or least point me to websites that go into great detail. I know the declaration but as far as what is going on with accessors, methods, constructors and destructors and even if you'd like to go as far as define when and why would the best time to use a class. I just need overall clarification. Thanks!

Answer 1

In programming, you have data and functions that manipulate that data. A structure (struct) allows you to group related pieces of data into one logical object.
A class allows you to group data and functions together as a single unit. Thus, instead of saying matrix_add(m1, m2), you can say m1.add(m2). The data and functions can be private (only accessible to the class), protected (accessible to the class and its children) or public (accessible to anyone). This is called encapsulation: typically, the data is private and is accessible via a set of public functions. In C++, a struct defaults to public scope and a class to private scope, but are otherwise identical.
An accessor is the name of a function that typically provides acccess to the private data of a class. These can be getters that return (or get) the data, or setters that modify (or set) the data. Typically, these methods check the input for validity to ensure internal constraints hold. Note that an accessor may not directly return private data, but derived properties; that is, size and empty on C++ containers (vector, list, ...) could be thought of as accessors even though these could be computed values.
A constructor is a special function that allows the class to initialize the data to sane values, or allow the user to create a new object of the class with potentially different data. For example, a rectangle class could be constructed from another rectangle, a point and size, a set of top/left/bottom/right values or could be empty. In C++, the constructor has the same name as the class; in python this is called __init__.
A default constructor is a constructor that takes no parameters and initializes the class to its default state (e.g. an identity matrix for a matrix class).
A copy constructor is a constructor that takes another object of the class type and creates a copy of it. This allows allocated memory to be handled properly (e.g. for string and vector classes). With a simple data structure the objects are copied by value, so the two objects would reference the same memory.
A destructor is a special function that allows the class to perform cleanup. This could be things like deleting any allocated memory, releasing locks on mutexes or closing open file handles. In C++, a destructor has the same name as the class but with a ~ in front of it, e.g. for a matrix class the destructor would be ~matrix.
A method is just a function that is a part of a class. Each method takes the class object being operated on as the first parameter. When declaring methods, C++ does this internally for you (providing an implicit this argument) while python requires you to provide the parameter explicitly.
In C++, an operator is a special function that is used to implement e.g. +, -, * and /. This allows you to create classes that can be used like built in types (esp. for mathematical classes like vectors, matrices, complex and rational numbers).
A class (the "derived" class) can inherit from another class (the "base" class). Here, the derived class is a child of the base class and can access any protected data or methods. This is called inheritance. These form a class heirarchy.
A class can be constructed to have virtual methods that can be overriden by derived classes. This is called polymorphism.
You can declare virtual methods that do not provide any implementation. These methods are called pure virtual methods and the classes that provide them are known as abstract base classes. Here, the derived class needs to implement these methods, while with non-pure virtual methods the derived class does not need to implement the method.
A class that only has pure virtual methods (no other methods) is effectively an interface class. C++ does not have any special notation for this, whereas other languages do.
Interfaces are typically used to interact between two or more different systems. For example, a music player could provide a plugin architecture that allows plugins to extend the supported audio formats it can handle. Here, the interface(s) provide the contract between the player and plugin.

Answer 2

Think of objects as "smart" structures which not just contain data but also the code to manipulate that data. Think of classes as type definitions for these "smart" structures.
Creating a class instance is just like creating a variable of a structure type. Calling a member function of a class is just like calling a normal function, and passing the structure to it as a parameter with the name "this".
When you understood this, you already understand most about what object-oriented programming is all about.
By the way: Do you know what's the difference between the keywords struct and class in C++? In a struct, all members are public by default and in a class all members are private by default. That's it. Otherwise structs and classes are the same thing. When you explicitely declare all members as private, public or protected, you can switch them out and the program will compile and work just like before.

Answer 3

And a common thing that keeps coming up is my failure to really understand whats going on when you are creating a class.
I'm answering this part as others have answered the second part, code below is java however, looking at the code kindly give importance to class concept than Java constructs.
Well, before jumping into the CLASS thing in the programming world. Lets take a look a the real world. If we look around us we see many elements [rocks, animals, humans, plants etc] in our living echo system. Careful observation finds that, they have some common features that can be grouped together [Life, Organs, Color etc] , lets call this common grouping by a technical name called "CLASS".
In order to understand, classes in programming world one should understand why there is such a construct called class. Main fact is the it is part of a programming paradigm called Object Oriented Programming, where, programmers try to map real world objects say Vehicles, Banks, etc into programming models called Objects. In order to create these object, we have to create a construct that can actually describe those objects. Such a construct is called a class.
Below explanations goes beyond just Classes for completeness.
Lets look at a technical example Circle, Rectangle, Square, Hexagon, looking at them we find that they belong to a common CLASS called SHAPE.
Don't get carried away by details [extends, #Override etc] in the example below. It explains simple concept of classing how it is exploited to make new classes. Once a class is created, it is just a skeleton ie it is not allocated any memory for a real use. In order to make a class useful, we create its objects. So objects are 'elements' with different states for same class.
Say for circle objects, obj1, obj2, each object have different radius.
class Shape {
String name;
int color;
public Shape(String name, int color) {
this.name = name;
this.color = color;
}
String getName() {
return name;
}
int getColor() {
return color;
}
double getArea() {
return 0;
}
double getPerimeter() {
return 0;
}
}
class Rectangle extends Shape {
int l, b;
public Rectangle(int l, int b, int h, int color) {
super("Rectangle", color);
this.l = l;
this.b = b;
}
/* Overloading */
#Override
double getArea() {
return l*b;
}
/* Overloading */
#Override
double getPerimeter() {
return (2*l + 2*b);
}
}
class Circle extends Shape {
int r;
public Circle(int r, int color) {
super("Circle", color);
this.r = r;
}
dobule getArea() {
return (PI * (r*r));
}
double getPerimeter() {
return (2*PI*r);
}
}