What is an object and a class?

[cobito]

For many it will be a silly question. I know how to program in C (ANSI C), Fortran, Matlab, x86 assembler... But I have never learned an object-oriented programming language. In C++ what is an object? and in Java what is a class?

What can be done with these languages that cannot be done with C?

I know that on Google there is an answer to these questions, but I do not understand them. If you could make analogies between what can be done in C and in C++ it would be good.

Thanks.

PD: This is just out of curiosity...

[kynes]

Cobito, I think that and dark matter are the two mysteries of science that remain to be solved.

[lforos]

This post is being processed/translated. The original version will be shown:

Pues se han escrito libros sobre el tema, así que para responder en un post …

Básicamente no es que haya nada que se pueda hacer con orientación a objetos que no se pueda hacer procedimentalmente (con C por ejemplo). Por simplificar, la orientación a objetos (OO) es una manera de programar más conceptual, tratando de representar el conocimiento de forma más estructurada. Así, además, se mejora la mantenibilidad del software y facilita la reusabilidad del código.

Básicamente, lo que se hace con lenguajes OO es agrupar conceptos en objetos con un sentido semántico en lo posible. Por ejemplo, puedes diseñar el objeto "cliente" que represente un cliente de tu empresa con todos los atributos que necesita el concepto (nombre, dirección, NIF, etc.) y toda la operativa relacionada con el objeto "cliente" (crear un cliente, borrar un cliente, cambiar domicilio, etc.). Todo en un mismo trozo de código. Los atributos puedes verlos como variables de una estructura en programación en C y los métodos como funciones y procedimientos de C.

La ventaja que tiene esta programación es variada. Por un lado, si tienes que hacer modificaciones es más sencillo (en principio) al estar todo lo relacionado con el objeto en la misma pieza de código. También, mientras no modifiques el interfaz, las modificaciones internas del objeto son transparentes al resto del codigo. Podrías, por ejemplo, sustituir un objeto por otro del mismo interfaz pero distinto comportamiento interno.

También se facilita la reusabilidad porque puedes usar la misma definición de objeto en otros programas al ser algo encapsulado. Basta con conocer el interfaz (las funciones y procedimientos públicos) para usarlo sin problemas.

Una clase es, por decirlo de alguna forma, una plantilla para un tipo de objeto, que define todas sus características. Un objeto sería una instancia de esa clase. Por ejemplo, puedes crear la clase "cliente" y luego, cuando creas un cliente concreto diríamos que estás creando el objeto.

No sé si está muy claro, pero es que estas no son horas .... Posiblemente te quede más claro con este ejemplo ...

! The Evolution of a Programmer
! High School/Jr.High
! 10 PRINT "HELLO WORLD"
20 END
! First year in College
! program Hello(input, output)
begin
writeln('Hello World')
end.
! Senior year in College
! (defun hello
(print
(cons 'Hello (list 'World))))
! New professional
! #include<stdio.h>
void main(void)
{
char message[] = {"Hello ", "World"};
int i;
! for(i = 0; i < 2; ++i)
printf("%s", message_);
printf("\n");
}
**
Seasoned professional*
! #include<iostream.h>
#include<string.h>
! class string
{
private:
int size;
char *ptr;
! string() : size(0), ptr(new char[1]) { ptr[0] = 0; }
! string(const string &s) : size(s.size)
{
ptr = new char;
strcpy(ptr, s.ptr);
}
! ~string()
{
delete [] ptr;
}
! friend ostream &operator <<(ostream &, const string &);
string &operator=(const char *);
};
! ostream &operator<<(ostream &stream, const string &s)
{
return(stream << s.ptr);
}
! string &string::operator=(const char chrs)
{
if (this != &chrs)
{
delete [] ptr;
size = strlen(chrs);
ptr = new char;
strcpy(ptr, chrs);
}
return(this);
}
! int main()
{
string str;
! str = "Hello World";
cout << str << endl;
! return(0);
}
**
Master Programmer
! [
uuid(2573F8F4-CFEE-101A-9A9F-00AA00342820)
]
library LHello
{
// bring in the master library
importlib("actimp.tlb");
importlib("actexp.tlb");
! // bring in my interfaces
#include "pshlo.idl"
! [
uuid(2573F8F5-CFEE-101A-9A9F-00AA00342820)
]
cotype THello
{
interface IHello;
interface IPersistFile;
};
};
! [
exe,
uuid(2573F890-CFEE-101A-9A9F-00AA00342820)
]
module CHelloLib
{
! // some code related header files
importheader(<windows.h>);
importheader(<ole2.h>);
importheader(<except.hxx>);
importheader("pshlo.h");
importheader("shlo.hxx");
importheader("mycls.hxx");
! // needed typelibs
importlib("actimp.tlb");
importlib("actexp.tlb");
importlib("thlo.tlb");
! [
uuid(2573F891-CFEE-101A-9A9F-00AA00342820),
aggregatable
]
coclass CHello
{
cotype THello;
};
};
! #include "ipfix.hxx"
! extern HANDLE hEvent;
! class CHello : public CHelloBase
{
public:
IPFIX(CLSID_CHello);
! CHello(IUnknown pUnk);
~CHello();
! HRESULT __stdcall PrintSz(LPWSTR pwszString);
! private:
static int cObjRef;
};
! #include<windows.h>
#include<ole2.h>
#include<stdio.h>
#include<stdlib.h>
#include "thlo.h"
#include "pshlo.h"
#include "shlo.hxx"
#include "mycls.hxx"
! int CHello::cObjRef = 0;
! CHello::CHello(IUnknown pUnk) : CHelloBase(pUnk)
{
cObjRef++;
return;
}
! HRESULT __stdcall CHello::PrintSz(LPWSTR pwszString)
{
printf("%ws
", pwszString);
return(ResultFromScode(S_OK));
}
! CHello::~CHello(void)
{
! // when the object count goes to zero, stop the server
cObjRef–;
if( cObjRef == 0 )
PulseEvent(hEvent);
! return;
}
! #include<windows.h>
#include<ole2.h>
#include "pshlo.h"
#include "shlo.hxx"
#include "mycls.hxx"
! HANDLE hEvent;
! int _cdecl main(
int argc,
char * argv[]
) {
ULONG ulRef;
DWORD dwRegistration;
CHelloCF pCF = new CHelloCF();
! hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
! // Initialize the OLE libraries
CoInitializeEx(NULL, COINIT_MULTITHREADED);
! CoRegisterClassObject(CLSID_CHello, pCF, CLSCTX_LOCAL_SERVER,
REGCLS_MULTIPLEUSE, &dwRegistration);
! // wait on an event to stop
WaitForSingleObject(hEvent, INFINITE);
! // revoke and release the class object
CoRevokeClassObject(dwRegistration);
ulRef = pCF->Release();
! // Tell OLE we are going away.
CoUninitialize();
! return(0); }
! extern CLSID CLSID_CHello;
extern UUID LIBID_CHelloLib;
! CLSID CLSID_CHello = { / 2573F891-CFEE-101A-9A9F-00AA00342820 /
0x2573F891,
0xCFEE,
0x101A,
{ 0x9A, 0x9F, 0x00, 0xAA, 0x00, 0x34, 0x28, 0x20 }
};
! UUID LIBID_CHelloLib = { / 2573F890-CFEE-101A-9A9F-00AA00342820 /
0x2573F890,
0xCFEE,
0x101A,
{ 0x9A, 0x9F, 0x00, 0xAA, 0x00, 0x34, 0x28, 0x20 }
};
! #include<windows.h>
#include<ole2.h>
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include "pshlo.h"
#include "shlo.hxx"
#include "clsid.h"
! int _cdecl main(
int argc,
char * argv[]
) {
HRESULT hRslt;
IHello pHello;
ULONG ulCnt;
IMoniker * pmk;
WCHAR wcsT[_MAX_PATH];
WCHAR wcsPath[2 * _MAX_PATH];
! // get object path
wcsPath[0] = '\0';
wcsT[0] = '\0';
if( argc > 1) {
mbstowcs(wcsPath, argv[1], strlen(argv[1]) + 1);
wcsupr(wcsPath);
}
else {
fprintf(stderr, "Object path must be specified\n");
return(1);
}
! // get print string
if(argc > 2)
mbstowcs(wcsT, argv[2], strlen(argv[2]) + 1);
else
wcscpy(wcsT, L"Hello World");
! printf("Linking to object %ws\n", wcsPath);
printf("Text String %ws\n", wcsT);
! // Initialize the OLE libraries
hRslt = CoInitializeEx(NULL, COINIT_MULTITHREADED);
! if(SUCCEEDED(hRslt)) {
! hRslt = CreateFileMoniker(wcsPath, &pmk);
if(SUCCEEDED(hRslt))
hRslt = BindMoniker(pmk, 0, IID_IHello, (void )&pHello);
! if(SUCCEEDED(hRslt)) {
! // print a string out
pHello->PrintSz(wcsT);
! Sleep(2000);
ulCnt = pHello->Release();
}
else
printf("Failure to connect, status: %lx", hRslt);
! // Tell OLE we are going away.
CoUninitialize();
}
! return(0);
}
! Apprentice Hacker
! #!/usr/local/bin/perl
$msg="Hello, world.\n";
if ($#ARGV >= 0) {
while(defined($arg=shift(@ARGV))) {
$outfilename = $arg;
open(FILE, ">" . $outfilename) || die "Can't write $arg: $!\n";
print (FILE $msg);
close(FILE) || die "Can't close $arg: $!\n";
}
} else {
print ($msg);
}
1;
**
Experienced Hacker
! #include<stdio.h>
#define S "Hello, World\n"
main(){exit(printf(S) == strlen(S) ? 0 : 1);}
! Seasoned Hacker
! % cc -o a.out ~/src/misc/hw/hw.c
% a.out
! Guru Hacker
! % echo "Hello, world."
**
New Manager
! 10 PRINT "HELLO WORLD"
20 END
! Middle Manager
! mail -s "Hello, world." bob@b12
Bob, could you please write me a program that prints "Hello, world."?
I need it by tomorrow.
^D
! Senior Manager
! % zmail jim
I need a "Hello, world." program by this afternoon.
**
Chief Executive
! % letter
letter: Command not found.
% mail
To: ^X ^F ^C
% help mail
help: Command not found.
% damn!
!: Event unrecognized
% logout
</stdio.h></stdio.h></string.h></stdlib.h></ole2.h></windows.h></ole2.h></windows.h></stdlib.h></stdio.h></ole2.h></windows.h></except.hxx></ole2.h></windows.h></string.h></iostream.h>_</stdio.h>

[cobito]

Thanks for the explanation. I get the idea, but it's not completely clear to me. I guess it's one of those things where until you dive in, you can't understand the concepts with any depth.

One of my next goals will be to learn C++ (I'm currently stuck with Arduino :ugly:).

[lforos]

Look at this entry to see if it clarifies something more with the examples it provides: Object-oriented programming | Javier Smaldone's Blog

[gamingpy]

Hello how are you cobito I program in java and I can tell you that a class is a set of objects that interact with each other for a certain function, for example if I create the class sum this class could help you add integers to say it somehow this is just an example of what you can do with classes in java. You should also keep in mind that certain classes may use libraries and imports to packages not available in the api so you will have to import it manually.

Example of Sum Class.

 Sum() { //The variables are initialized and the default constructor of the class is defined int number1, number2; Sum (int n1, int n2){  this.number1 = n1: this.number2 =n2;  }  //Method that returns the result of the sum of numbers - Method of the Sum class public int Result(){  int res;  res = number1 + number2;  return res;  } } 

[cobito]

Thanks for your reply. Although it's been over a year since I made it, I still had it.

Actually, it's still not entirely clear to me, but I suppose it's one of those things that you end up understanding when you apply them.

For now, C still meets all my needs, but C++ still catches my attention. Too bad I don't have the time.