¿Qué es un objeto y una clase?


  • 0

    Para muchos será una pregunta de perogrullo. Yo sé programar en C (ANSI C), Fortran, Matlab, ensamblador del x86… Pero nunca he aprendido un lenguaje de programación orientado a objetos. En C++ ¿qué es un objeto? y en Java ¿qué es una clase?

    ¿Qué se puede hacer con estos lenguajes que no se pueda hacer con C?

    Sé que en Google hay respuesta a estas preguntas, pero no las entiendo. Si pudiérais hacer analogías entre lo que se puede hacer en C y en C++ estaría bien.

    Gracias.

    PD: Esto es sólo por curiosidad...



  • 1

    Cobito, creo que eso y la materia oscura son los dos misterios de la ciencia que quedan por resolver.



  • 2

    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>



  • 3

    Gracias por la explicación. Me hago una idea, pero no me queda completamente claro. Supongo que es una de esas cosas en las que hasta que no te adentras, no puedes comprender con cierta profundidad los conceptos.

    Uno de mis próximo objetivos será aprender C++ (ahora estoy liado con Arduino :ugly:).



  • 4

    Mira esta entrada a ver si te aclara algo más con los ejemplos que pone: Programación orientada a objetos | Blog de Javier Smaldone



  • 5

    Hola que tal cobito yo programo en java y te puedo decir que una clase es un conjunto de objetos el cual interactuan entre si para una determinada funcion , por ejemplo si creara la clase suma esta clase podria ayudarte a sumar numeros enteros por decirlo de alguna manera asi es solo un ejemplo de lo que puedes hcaer con las clases en java. Tambien debes de tener encuenta que ciertas clases pueden utilizar librerias he importaciones a paquetes no disponibles en la api por lo que tendras que importarlo manualmente.

    Ejemplo de Clase Suma.

    
    Suma() {
    //Se inicializa las variables y se define el constructor por defecto de la clase
    int numero1, numero2;
    Suma (int n1 , int n2){
    
    this.numero1 = n1:
    this.numero2 =n2;
    
    }
    
    //Metodo que devuela el resultado de la suma de numeros - Metodo de la clase Suma
    public int Resultado(){
    
    int res;
    
    res = numero1 + numero2;
    
    return res;
    
    }
    }
    


  • 6

    Gracias por respuesta. Aunque hace más de un año que la hice, todavía la tenía.

    En realidad no me termina de quedar claro pero supongo que es una de esas cosas que se acaban entendiendo cuando se aplican.

    De momento C sigue supliendo todas mis necesidades pero C++ me sigue llamando la atención. Una pena no disponer de tiempo.





Has perdido la conexión. Reconectando a Hardlimit.