Ejemplos 1

https://www.geeksforgeeks.org/object-oriented-programming-in-cpp/

https://www.educba.com/software-development/software-development-tutorials/c-plus-plus-
programming-tutorial/

Los lenguajes de programación antiguos, como C, Basic o COBOL, seguían un

estilo procedimental a la hora de escribir código. Es decir, los programas
escritos en estos lenguajes consistían en una serie de instrucciones, una
detrás de otra, que se ejecutaban paso a paso. Para "encerrar" funcionalidad
y poder reutilizarla definían procedimientos (también llamados subrutinas o
funciones), pero se usaban datos globales y era muy complicado aislar los
datos específicos unos de otros. Podríamos decir que este tipo de lenguajes
se centraban más en la lógica que en los datos.

Sin embargo, los lenguajes modernos como C#, Java o... en realidad casi
cualquiera, utilizan otros paradigmas para definir los programas. Entre éstos,
el paradigma más popular es el que se refiere a la Programación Orientada
a Objetos o POO.
En este paradigma, los programas se modelan en torno a objetos que
aglutinan toda la funcionalidad relacionada con ellos. De este modo en lugar
de crear una serie de funciones sin conexión alguna entre ellas, en POO se
crean clases, que representan entidades que quieres manejar en tu
programa. Por ejemplo, facturas, líneas de factura, clientes, coches... o
cualquier entidad que necesites gestionar conceptualmente. En ese
sentido, la POO gira más en torno a los datos que en torno a la lógica,
que se delega a un segundo plano, ya que forma parte de dichos datos como
veremos enseguida.
La POO puede resultar confusa para mucha gente al principio, cuando se
entra en contacto con ella. Por eso me he animado a grabar el vídeo que
tienes al principio, y a escribir este artículo, en los que te voy a explicar con
las palabras más sencillas posibles los principales conceptos de la
Programación Orientada a Objetos, independientemente del lenguaje de
programación que utilices.

Clases, objetos e instancias

El primer concepto y más importante de la POO es la distinción entre clase
y objeto.
Una clase es una plantilla. Define de manera genérica cómo van a ser los
objetos de determinado tipo. Por ejemplo, en un juego, una clase para
representar a personas puede llamarse Persona y tener una serie
de atributos como Nombre, Apellidos o Edad (que normalmente son
propiedades), y una serie de comportamientos que pueden tener,
como Hablar(), Caminar() o Comer() y que se implementan
como métodos de la clase (funciones).
Una clase por sí sola no sirve de nada, pues no es más que un concepto, sin
entidad real. Para poder utilizar una clase en un programa lo que hay que
hacer es instanciarla. Instanciar una clase consiste en crear un nuevo
objeto concreto de la misma. Es decir, un objeto es ya una entidad
concreta que se crea a partir de la plantilla que es la clase. Este nuevo
objeto tiene ya "existencia" real, puesto que ocupa memoria y se puede
utilizar en el programa. Así un objeto puede ser una persona que se
llama Cristina López, de 37 años y que en nuestro programa podría
hablar, caminar o comer, que son los comportamientos que están definidos
en la clase.

Una imagen vale más que mil palabras:

De este modo, si tenemos que manejar personas podemos ir creándolas a
medida que las necesitemos, y actuar sobre ellas individualmente. Cada una
tiene sus propios datos y sus propias acciones.

La clase define de forma genérica cómo son las personas, y los objetos son
personas concretas.

La POO es muy potente porque nos permite modelar de manera sencilla

datos y comportamientos complejos del mundo real. Al poder manejar los
datos y los comportamientos de cada objeto de manera independiente nos
evita tener que mantener datos globales y coordinar todo eso. En su
momento fue una verdadera revolución.
Los cuatro pilares de la POO
Lo anterior por si solo es estupendo. Sin embargo, no es suficiente. Para
poder manejar de manera eficiente las clases y los objetos que se generan
con la Programación Orientada a Objetos son necesarios algunos principios
que nos ayudarán a reducir la complejidad, ser más eficientes y evitar
problemas. Son los 4 pilares de la POO. Todos los lenguajes orientados a
objetos los implementan de una u otra manera, y es indispensable
conocerlos bien.

Vamos a verlos

Pilar 1: Encapsulación

El concepto de encapsulación es el más evidente de todos. Pero,

precisamente por su sencillez, a veces pasa inadvertido.

La encapsulación es la característica de un lenguaje POO que permite que

todo lo referente a un objeto quede aislado dentro de éste. Es decir, que
todos los datos referentes a un objeto queden "encerrados" dentro de éste y
sólo se puede acceder a ellos a través de los miembros que la clase
proporcione (propiedades y métodos).

Por ejemplo, en el caso de las personas que estábamos viendo, toda la

información sobre éstas (nombre, apellidos, edad... y cualquier otro dato
interno que se utilice y que no necesariamente se ve desde el exterior del
objeto) está circunscrito al ámbito de dicha persona.

Así, internamente tenemos un dato que es el nombre de la persona y

accedemos a él a través de la propiedad pública Nombre que define la clase
que representa a las personas. De este modo damos acceso sólo a lo que
nos interese y del modo que nos interese. En un lenguaje tradicional
tendríamos que montar alguna estructura global para almacenar esa
información y luego acceder ordenadamente a ella, sin mezclar los datos de
una persona con los de otra.

Gracias a la encapsulación, toda la información de un objeto está contenida

dentro del propio objeto.
Pilar 2: Abstracción

Este concepto está muy relacionado con el anterior.

Como la propia palabra indica, el principio de abstracción lo que implica es

que la clase debe representar las características de la entidad hacia el
mundo exterior, pero ocultando la complejidad que llevan aparejada. O
sea, nos abstrae de la complejidad que haya dentro dándonos una serie de
atributos y comportamientos (propiedades y funciones) que podemos usar
sin preocuparnos de qué pasa por dentro cuando lo hagamos.

Así, una clase (y por lo tanto todos los objetos que se crean a partir de ella)
debe exponer para su uso solo lo que sea necesario. Cómo se haga "por
dentro" es irrelevante para los programas que hagan uso de los objetos de
esa clase.

En nuestro ejemplo de las personas en un juego, puede ser que tengamos

un dato interno que llamamos energía y que nunca es accesible
directamente desde fuera. Sin embargo, cada vez que la persona anda (o
corre, si tuviésemos un método para ello) gasta energía y el valor de este
dato disminuye. Y cuando la persona come, el valor sube en función de lo
que haya comido.

Otro ejemplo incluso más claro podría ser la acción Hablar(). Ésta puede
suponer que se genere una voz sintética a partir de un texto que se le indica
como parámetro de la acción para lo cual quizá ocurran un montón de cosas:
se llama a un componente para síntesis de voz que está en la nube, se lanza
la síntesis de voz en el dispositivo local de audio y se anota en una base de
datos la frase que se ha pronunciado para guardar un histórico entre otras
cosas. Pero todo esto es indiferente para el programa que hace uso de esta
funcionalidad. El programa simplemente tiene acceso a un
objeto Cristina y llama a la función Hablar(). No tiene ni idea de toda la
complejidad interna que puede suponer. Si mañana cambiamos el modo de
sintetizar la voz o cualquier otra acción interna, es indiferente para el
programa que usa nuestros objetos de tipo Persona.
La abstracción está muy relacionada con la encapsulación, pero va un paso
más allá pues no sólo controla el acceso a la información, sino también
oculta la complejidad de los procesos que estemos implementando.

Pilar 3: Herencia
Desde el punto de vista de la genética, cuando una persona obtiene de sus
padres ciertos rasgos (el color de los ojos o de la piel, una enfermedad
genética, etc...) se dice que los hereda. Del mismo modo en POO cuando
una clase hereda de otra obtiene todos los rasgos que tuviese la
primera.
Dado que una clase es un patrón que define cómo es y cómo se comporta
una cierta entidad, una clase que hereda de otra obtiene todos los rasgos de
la primera y añade otros nuevos y además también puede modificar
algunos de los que ha heredado.
A la clase de la que se hereda se le llama clase base, y a la clase que hereda
de ésta se le llama clase derivada.

Así, en nuestro juego que involucra personas, podemos tener clases de

personas más especializadas para representar personajes especiales del
juego. Por ejemplo, podríamos definir clases
como Pirata, Piloto o Estratega que heredan de la clase Persona.
Todos los objetos de estas clases heredan las propiedades y los métodos
de Persona, pero pueden particularizar algunos de ellos y además añadir
cosas propias.

Por ejemplo, los objetos de la clase Pirata tienen un método nuevo que
es Abordar() que en el juego sirve para asaltar un barco enemigo. Pero
además presentan una propiedad que solo tienen los piratas
llamada Sobrenombre, que es el nombre por el que se les conoce (un pirata
puede ser de nombre Hızır y de apellido bin Yakup pero su sobrenombre
es Barbaroja).

No solo eso. Lo bueno de la herencia es que podemos reutilizar todo lo que

tuviésemos en la clase base. Supongamos que en nuestro juego, los piratas
hablan de forma diferente a los demás. El método Hablar() se modifica
para que le añada un ¡Arrrr! o un ¡Por todos los
demonios! aleatoriamente a la frase y que así parezca más un pirata 😆. Para
que el pirata hable no tendríamos que volver a hacer todo el código
relacionado con hablar. Eso ya sabe cómo hacerlo por el mero hecho de ser
una persona (por heredar de la clase Persona). Lo único que tendríamos
que hacer es añadir esas interjecciones de pirata a la frase y luego delegar la
síntesis de voz y todo lo demás a la clase base. Sería facilísimo y
conseguiríamos consistencia entre todas las clases a la hora de particularizar
la forma de hablar.

La herencia es una de las características más potentes de la POO ya que

fomenta la reutilización del código permitiendo al mismo tiempo la
particularización o especialización del mismo.

Pilar 4: Polimorfismo

La palabra polimorfismo viene del griego "polys" (muchos) y "morfo" (forma),

y quiere decir "cualidad de tener muchas formas".

En POO, el concepto de polimorfismo se refiere al hecho de que varios

objetos de diferentes clases, pero con una base común, se pueden usar
de manera indistinta, sin tener que saber de qué clase exacta son para
poder hacerlo.

Supongamos que en nuestro juego tenemos un montón de personajes que

están juntos en un mismo escenario. Hay varios piratas, algunos estrategas y
un montón de otros tipos de personas. En un momento dado necesitamos
que todos se pongan a hablar. Cada uno lo hace de una forma diferente, ya
que son tipos de personajes distintos. Sería algo bastante tedioso tener que
localizar primero a los de un tipo y hacerlos hablar, lo luego a los de otro y
así sucesivamente. La idea es que puedas tratarlos a todos como personas,
independientemente del tipo específico de persona que sean y simplemente
decirles que hablen.

Al derivar todos de la clase Persona todos pueden hablar, y al llamar al

método Hablar() de cada uno de ellos se utilizará el proceso adecuado
según el tipo (los piratas meterán sus expresiones adicionales que hemos
visto, los pilotos dirán "Entrando en pista" o lo que sea, y los estrategas
añadirán a todo "Déjame que lo piense bien"). Todo esto de manera
transparente para el programador. Esto es el polimorfismo.

De hecho, el polimorfismo puede ser más complicado que eso ya que se

puede dar también mediante la sobrecarga de métodos y, sobre todo, a
través del uso de interfaces, pero el concepto es el que acabo de explicar.

El polimorfismo nos permite utilizar a los objetos de manera genérica,

aunque internamente se comporten según su variedad específica.
Gracias a estos cuatro principios que cumplen todos los lenguajes
orientados a objetos se facilita mucho la programación de ciertos tipos de
problemas, se minimizan errores, se escribe código más rápido y se puede
mantener más fácilmente cuando haya modificaciones en el futuro.
-----------------------------------------------------------------------------------------------------------------------------------------

La programación orientada a objetos, o POO, es una metodología de

diseño y programación que se basa en la organización de datos y
comportamientos en estructuras llamadas "objetos". Aunque puede
sonar técnico al principio, este enfoque revoluciona la forma en que
creamos y estructuramos software…

…al alinear más estrechamente nuestro código con cómo vemos y

categorizamos el mundo real, la POO nos permite escribir software más
organizado, reutilizable y fácil de entender.

0. Abstracción: simplificando la Realidad

La abstracción es uno de los pilares fundamentales de la programación
orientada a objetos: nos permite modelar el mundo real en términos
de código, eligiendo qué propiedades y comportamientos son
esenciales para nuestro software y cuáles pueden ser ignorados. Esto
hace que el diseño del software sea más manejable, manteniendo el
enfoque en la funcionalidad clave.

En la programación, la abstracción a menudo se logra mediante la

creación de clases y objetos. Estas clases sirven como plantillas o
modelos que capturan la esencia de algo, sin entrar minuciosamente en
todos los detalles (o atributos).

1. ¿Qué es un objeto?
En el mundo real, estamos rodeados de objetos: tu taza de café, tu
teléfono, tu bicicleta. Estos objetos tienen características (color, tamaño,
modelo) y comportamientos (una taza contiene líquido, un teléfono
puede hacer llamadas). En POO, modelamos estas entidades reales como
"objetos" en código.

Por ejemplo, considera una sencilla definición de un coche:

class Coche:
# Constructor de la clase
def init(self, marca, modelo):
self.marca = marca
self.modelo = modelo
# Método para describir el coche
def describir(self):
return f"Este coche es un {self.marca} {self.modelo}"

Aquí, marca y modelo son características, mientras que describir es un

comportamiento.

2. Clases: Los moldes de los objetos

La definición anterior (Coche) es lo que llamamos una clase. Piensa en la
clase Coche como un plano que nos dice cómo debería ser cada coche
que salga de la fábrica en términos de programación.

O podemos plantearlo en términos más domésticos: imaginemos que

estás en la cocina, listo para hacer galletas. Tienes un molde de
galletas que te ayudará a darles una forma específica. Este molde es lo
que en POO llamamos una clase. Es una definición o plantilla que nos
dice cómo se verán y comportarán nuestras galletas.

Ahora bien, cuando usas el molde para hacer una galleta, esa galleta
individual es un objeto. Aunque proviene de un molde común, cada
galleta es única y puede tener sus propias particularidades, como chispas
de chocolate o trocitos de nuez.

3. Creación de objetos: instanciando una

clase
Una vez que tengas una clase, puedes crear objetos específicos
o instancias de esa clase. Siguiendo con nuestro ejemplo:

mi_coche = Coche("Toyota", "Corolla")

print(mi_coche.describir()) # Salida: Este coche es un Toyota Corolla

4. Atributos y métodos

Un mismo objeto 'Chico' puede tener varios atributos, diferentes o en común con respecto a otros
objetos de la misma clase
Piensa en cómo describirías a tu mejor amigo: tiene nombre, edad, color
de ojos, hobbies, etc. Estas características individuales son similares a
los atributos en POO. Es decir, son las propiedades específicas que un
objeto (como nuestra galleta) puede tener.

Además de tener características, las personas pueden hacer cosas: cantar,

bailar, correr, etc. En POO, estos comportamientos o acciones son
los métodos. Son acciones que un objeto puede realizar.

El mismo objeto 'monigote' haciendo uso de tres métodos distintos…

En nuestros ejemplos anteriores, 'Coche', 'marca' y 'modelo' son atributos,

mientras que 'describir()' es un método.

5. Herencia: Tomando lo mejor de otros

Cuando hablamos de familias, a menudo escuchamos que alguien "ha
heredado" el color de ojos de su madre o el talento musical de su padre.
En POO, la herencia permite que una clase (recuerda, el molde de
galletas) tome atributos y métodos de otra clase. Es como si una nueva
receta de galletas tomara ingredientes de una receta anterior y
agregara algo más.

Supongamos que queremos tener una clase CocheElectrico que comparta

algunas características con Coche pero que tenga algunas adicionales:
class CocheElectrico(Coche):
def init(self, marca, modelo, autonomia):
super().init(marca, modelo)
self.autonomia = autonomia
def autonomia_restante(self, distancia_recorrida):
return self.autonomia - distancia_recorrida

El CocheElectrico es un tipo especial de Coche, pero tiene una característica

adicional: autonomia. También tiene un método adicional para determinar
la autonomía restante.
6. Polimorfismo: Una función, muchas
formas
El polimorfismo se refiere a la capacidad de diferentes clases de ser
tratadas como instancias de la misma clase a través de la herencia. Es
una forma elegante de decir que diferentes objetos pueden realizar una
acción de la misma manera.

Considerando las clases anteriores, aunque Coche y CocheElectrico son

diferentes, ambos pueden usar el mismo método describir(). Este es
un simple ejemplo de polimorfismo.

7. Encapsulamiento: Protegiendo nuestro

código

El encapsulamiento es la práctica de ocultar los detalles internos de

cómo una clase realiza sus acciones. Imagina que tienes una mochila
donde guardas tus cosas. Cuando la cierras, no necesitas saber
exactamente cómo está todo organizado dentro.

En POO, el encapsulamiento es como esa mochila: protege y oculta los

detalles internos de un objeto, permitiendo que interactuemos con él de
manera simple y segura. En Python, por ejemplo, usamos guiones bajos
para denotar atributos o métodos privados:
class Coche:
def __init__(self, marca, modelo):
self._codigo_secreto = "12345"
self.marca = marca
self.modelo = modelo

Aquí, _codigo_secreto es un atributo protegido, que idealmente no debería

ser accedido directamente fuera de la clase.

Pero, ¿por qué deciemos que es más seguro recurrir al encapsulamiento?

Veamos:
1. Protección de datos internos: El encapsulamiento permite
restringir el acceso directo a determinados atributos o métodos
de una clase. Esto significa que podemos proteger y controlar
cómo se accede y modifica la información interna de un objeto,
evitando manipulaciones indebidas.
2. Flexibilidad y mantenimiento: Si en el futuro necesitas cambiar
la forma en que se implementa una característica particular,
gracias al encapsulamiento, puedes hacerlo sin alterar el código
que utiliza esa clase. Esto reduce el riesgo de errores cuando se
hacen modificaciones.
8. Composición: construyendo objetos a
partir de otros

La composición implica construir clases utilizando otras clases como

partes. Imagina construir un robot usando piezas individuales; cada
pieza es esencial para la función completa del robot.

Por ejemplo, un objeto Coche puede estar compuesto objetos

como Motor, Ruedas o Chasis.

9. Interfaces: un contrato entre clases

Las interfaces juegan un papel fundamental en muchos lenguajes de
programación orientada a objetos. Puedes pensar en una interfaz como
un contrato que una clase decide firmar. Este contrato estipula que la
clase implementará ciertos métodos, pero no dicta cómo deben
implementarse esos métodos. En otras palabras, la interfaz define qué se
debe hacer, pero deja el cómo hacerlo a la clase que la implementa.

Imagina un control remoto universal: tiene botones para encender,

apagar, subir el volumen, bajar el volumen, etc. No importa la marca o el
modelo de televisión, si deseas que ese televisor sea compatible con el
control remoto universal, debe cumplir con ciertas funciones básicas. De
manera similar, una interfaz define un conjunto de métodos que
cualquier clase que implemente esa interfaz debe tener.

Vamos a ver un ejemplo simplificado usando Python. Aunque Python no

tiene un soporte directo para interfaces como otros lenguajes (como
Java), podemos simularlo usando clases abstractas:
from abc import ABC, abstractmethod
class Encendible(ABC):
@abstractmethod
def encender(self):
pass

@abstractmethod
def apagar(self):
pass

class Bombilla(Encendible):
def encender(self):
print("Bombilla encendida!")

def apagar(self):
print("Bombilla apagada!")

Aquí, Encendible es nuestra interfaz que dicta que cualquier objeto que
pueda ser encendido y apagado debe tener los
métodos encender() y apagar(). La clase Bombilla implementa esta interfaz y
define cómo se enciende y se apaga una bombilla.

Las interfaces son una herramienta poderosa en la POO, ya

que promueven la reutilización de código y aseguran que ciertas
clases tengan comportamientos esperados, actuando como un
estándar que debe seguirse. Además, ayudan a desacoplar el código,
permitiendo que los sistemas sean más flexibles y adaptables a cambios
futuros.

Epílogo: Historia de la Programación

Orientada a Objetos (POO)
La programación orientada a objetos (POO) se desarrolló como una
respuesta a las crecientes necesidades y desafíos de la ingeniería de
software, buscando proporcionar estructuras más modulares,
reutilizables y fácilmente mantenibles.
1. 1960s - Simula: El origen de la POO se encuentra en el lenguaje
de programación Simula, que introdujo los primeros conceptos
de programación orientados a objetos, aunque el propio
término "orientado a objetos" aún no había sido acuñado.
 2. 1970s - Smalltalk: En la década de 1970, el lenguaje Smalltalk
se convirtió en el primer lenguaje de programación totalmente
orientado a objetos. Introdujo conceptos como clases,
instancias, herencia y encapsulamiento, y popularizó la POO.
3. 1980s - C++: Durante la década de 1980, Bjarne Stroustrup
desarrolló C++, que añadió características orientadas a objetos
al lenguaje C. C++ jugó un papel crucial en hacer de la POO una
técnica dominante en la ingeniería de software, dada su
compatibilidad con C y su poderosa combinación de
programación procedural y orientada a objetos.
4. 1990s - Java: En la década de 1990, Sun Microsystems introdujo
Java, diseñado con una orientación a objetos desde su núcleo.
Java llevó la POO a la vanguardia de la ingeniería de software a
gran escala y al desarrollo web, gracias a su portabilidad y su
promesa de "Escribirlo una vez, ejecutarlo en cualquier sitio".
5. Otros Lenguajes: A lo largo de los años, varios otros lenguajes
han incorporado soporte para POO, incluidos Python, Ruby, C#,
PHP y muchos más. Estos lenguajes han adaptado y
evolucionado los principios básicos de POO para satisfacer
diferentes necesidades y paradigmas.
-------------------------------------------------------------------------------

#include <stdio.h>

void Print(char c) {
printf("%c", c);
}

void Print(int i) {
printf("%i", i);
}

void Print(long int l) {

printf("%li", l);
}

void Print(float f) {
 printf("%f", f);
}

void Print(void *p) {

printf("%p", p);
}

void Print(char *s) {

printf("%s", s);
}

void Print() {
printf("\n"); // Nueva l¡nea
}

void main() {
int i= 1;
char c= 'a';
long l= 10L;
float f= 3.3;
char * s= "Hola, aprendices de magia con C++";
void * p= (void *)s;

Print(s);
Print();
Print(i);
Print();
Print(c);
Print();
Print(l);
Print();
Print(f);
Print();
Print(p); // Direcci¢n de la cadena
Print();
}

#include <stdio.h>

// La funci¢n scanf requiere un puntero, por eso ponemos &

void Scan(char & c) {

scanf("%c", &c);
}

void Scan(int & i) {

scanf("%i", &i);
}

void Scan(long & l) {

scanf("%li", &l);
}

void Scan(float & f) {

 scanf("%f", &f);
}

void Scan(void * & p) {

scanf("%p", &p);
}

void Scan(char *s) {

scanf("%s", s);
}

void main() {
int i;
char c;
long l;
float f;
void * p;
char s[100];

printf("Introduce un entero, un caracter, un long,");

printf(" un real, un puntero y una cadena (separados por INTRO)\n");
Scan(i);
Scan(c);
Scan(c);
// Se pone dos veces porque el primero lee el '\n' del Scan anterior.
Scan(l);
Scan(f);
Scan(p);
Scan(s);
}
------------------------------------------------------------------------------------------------------------------------------------

CAUSA ERROR, EL SEGUNDO FUNCIONA BIEN CON STATIC

#include <stdio.h>

// Inline function in C

inline int foo()

return 2;

int main()

int ret;

// inline function call

ret = foo();
 printf("Output is: %d\n", ret);

return 0;

--------------------------------------------

#include <stdio.h>

// Inline function in C

static inline int foo()

return 2;

// Driver code

int main()

int ret;

// inline function call

ret = foo();

printf("Output is: %d\n", ret);

return 0;

#include <stdio.h>
// defining inline function with inline keywordfor addition
static inline int addition(int a, int b)
{
return a + b ; // returning the output value as per requirement
}
// Main user code
Int main()
{
inta, b, x ;
printf( " Please enter the value of integer a : " ) ;
scanf( "%d", &a ) ;
printf( " Please enter the value of integer b : " ) ;
scanf( "%d" , &b ) ;
// Calling the inline function by reference
x = addition( a , b ) ;
printf( " The result of addition of the given integers is : %d\
n " , x ) ;
return 0 ;
}

#include <stdio.h>
// defining inline function with inline keyword
static inline int subtraction(int a, int b)
{
return a - b ; // returning the output value as per requirement
}
// Main user code
Int main()
{
inta, b, x ;
printf( " Please enter the value of integer a : " ) ;
scanf( "%d", &a ) ;
printf( " Please enter the value of integer b : " ) ;
scanf( "%d" , &b ) ;
// Calling the inline function
x = subtraction( a , b ) ; // making a reference to inline
function.
printf( " The result of subtraction of the given integers is :
%d\n " , x ) ;
return 0 ;
}
#include <iostream>
using namespace std;
int main() {
cout << "Hello Welcome to C++ Programming";
return 0;
}

Object Oriented Programming in C++

Read
Courses
Practice
Video



Object-oriented programming – As the name suggests uses objects in programming.
Object-oriented programming aims to implement real-world entities like inheritance,
hiding, polymorphism, etc. in programming. The main aim of OOP is to bind together the
data and the functions that operate on them so that no other part of the code can access
this data except that function.
There are some basic concepts that act as the building blocks of OOPs i.e.
1. Class
2. Objects
3. Encapsulation
4. Abstraction
5. Polymorphism
6. Inheritance
7. Dynamic Binding
8. Message Passing
Characteristics of an Object-Oriented Programming
Language
Class
The building block of C++ that leads to Object-Oriented programming is a Class. It is a
user-defined data type, which holds its own data members and member functions, which
can be accessed and used by creating an instance of that class. A class is like a blueprint
for an object. For Example: Consider the Class of Cars. There may be many cars with
different names and brands but all of them will share some common properties like all of
them will have 4 wheels, Speed Limit, Mileage range, etc. So here, the Car is the class,
and wheels, speed limits, and mileage are their properties.
 A Class is a user-defined data type that has data members and member
functions.
 Data members are the data variables and member functions are the functions
used to manipulate these variables together these data members and member
functions define the properties and behavior of the objects in a Class.
 In the above example of class Car, the data member will be speed limit,
mileage, etc and member functions can apply brakes, increase speed, etc.
We can say that a Class in C++ is a blueprint representing a group of objects which
shares some common properties and behaviors.
Object
An Object is an identifiable entity with some characteristics and behavior. An Object is
an instance of a Class. When a class is defined, no memory is allocated but when it is
instantiated (i.e. an object is created) memory is allocated.

 C++

// C++ Program to show the syntax/working of Objects as a

// part of Object Oriented PProgramming
#include <iostream>
using namespace std;

class person {
char name[20];
int id;

public:
void getdetails() {}
};

int main()
{

person p1; // p1 is a object

 return 0;
}

Objects take up space in memory and have an associated address like a record in pascal
or structure or union. When a program is executed the objects interact by sending
messages to one another. Each object contains data and code to manipulate the data.
Objects can interact without having to know details of each other’s data or code, it is
sufficient to know the type of message accepted and the type of response returned by the
objects.
To know more about C++ Objects and Classes, refer to this article – C++ Classes and
Objects
Encapsulation
In normal terms, Encapsulation is defined as wrapping up data and information under a
single unit. In Object-Oriented Programming, Encapsulation is defined as binding
together the data and the functions that manipulate them. Consider a real-life example of
encapsulation, in a company, there are different sections like the accounts section, finance
section, sales section, etc. The finance section handles all the financial transactions and
keeps records of all the data related to finance. Similarly, the sales section handles all the
sales-related activities and keeps records of all the sales. Now there may arise a situation
when for some reason an official from the finance section needs all the data about sales in
a particular month. In this case, he is not allowed to directly access the data of the sales
section. He will first have to contact some other officer in the sales section and then
request him to give the particular data. This is what encapsulation is. Here the data of the
sales section and the employees that can manipulate them are wrapped under a single
name “sales section”.

Encapsulation in C++

Encapsulation also leads to data abstraction or data hiding. Using encapsulation also
hides the data. In the above example, the data of any of the sections like sales, finance, or
accounts are hidden from any other section.
To know more about encapsulation, refer to this article – Encapsulation in C++
Abstraction
Data abstraction is one of the most essential and important features of object-oriented
programming in C++. Abstraction means displaying only essential information and
hiding the details. Data abstraction refers to providing only essential information about
the data to the outside world, hiding the background details or implementation. Consider
a real-life example of a man driving a car. The man only knows that pressing the
accelerator will increase the speed of the car or applying brakes will stop the car but he
does not know how on pressing the accelerator the speed is actually increasing, he does
not know about the inner mechanism of the car or the implementation of an accelerator,
brakes, etc. in the car. This is what abstraction is.
 Abstraction using Classes: We can implement Abstraction in C++ using
classes. The class helps us to group data members and member functions using
available access specifiers. A Class can decide which data member will be
visible to the outside world and which is not.
 Abstraction in Header files: One more type of abstraction in C++ can be
header files. For example, consider the pow() method present in math.h header
file. Whenever we need to calculate the power of a number, we simply call the
function pow() present in the math.h header file and pass the numbers as
arguments without knowing the underlying algorithm according to which the
function is actually calculating the power of numbers.
To know more about C++ abstraction, refer to this article – Abstraction in C++
Polymorphism
The word polymorphism means having many forms. In simple words, we can define
polymorphism as the ability of a message to be displayed in more than one form. A
person at the same time can have different characteristics. A man at the same time is a
father, a husband, and an employee. So the same person possesses different behavior in
different situations. This is called polymorphism. An operation may exhibit different
behaviors in different instances. The behavior depends upon the types of data used in the
operation. C++ supports operator overloading and function overloading.
 Operator Overloading: The process of making an operator exhibit different
behaviors in different instances is known as operator overloading.
 Function Overloading: Function overloading is using a single function name
to perform different types of tasks. Polymorphism is extensively used in
implementing inheritance.
Example: Suppose we have to write a function to add some integers, sometimes there are
2 integers, and sometimes there are 3 integers. We can write the Addition Method with
the same name having different parameters, the concerned method will be called
according to parameters.

Polymorphism in C++

To know more about polymorphism, refer to this article – Polymorphism in C++

Inheritance
The capability of a class to derive properties and characteristics from another class is
called Inheritance. Inheritance is one of the most important features of Object-Oriented
Programming.
 Sub Class: The class that inherits properties from another class is called Sub
class or Derived Class.
 Super Class: The class whose properties are inherited by a sub-class is called
Base Class or Superclass.
 Reusability: Inheritance supports the concept of “reusability”, i.e. when we
want to create a new class and there is already a class that includes some of the
code that we want, we can derive our new class from the existing class. By
doing this, we are reusing the fields and methods of the existing class.
Example: Dog, Cat, Cow can be Derived Class of Animal Base Class.

Inheritance in C++

To know more about Inheritance, refer to this article – Inheritance in C++

Dynamic Binding
In dynamic binding, the code to be executed in response to the function call is decided at
runtime. C++ has virtual functions to support this. Because dynamic binding is flexible, it
avoids the drawbacks of static binding, which connected the function call and definition
at build time.
Example:
 C++

// C++ Program to Demonstrate the Concept of Dynamic binding

// with the help of virtual function
#include <iostream>
using namespace std;

class GFG {
public:
void call_Function() // function that call print
{
print();
}
void print() // the display function
{
cout << "Printing the Base class Content" << endl;
}
};
class GFG2 : public GFG // GFG2 inherit a publicly
{
public:
void print() // GFG2's display
{
cout << "Printing the Derived class Content"
 << endl;
}
};
int main()
{
GFG geeksforgeeks; // Creating GFG's object
geeksforgeeks.call_Function(); // Calling call_Function
GFG2 geeksforgeeks2; // creating GFG2 object
geeksforgeeks2.call_Function(); // calling call_Function
// for GFG2 object
return 0;
}

Output
Printing the Base class Content
Printing the Base class Content
As we can see, the print() function of the parent class is called even from the derived
class object. To resolve this we use virtual functions.

Message Passing
Objects communicate with one another by sending and receiving information. A message
for an object is a request for the execution of a procedure and therefore will invoke a
function in the receiving object that generates the desired results. Message passing
involves specifying the name of the object, the name of the function, and the information
to be sent.
Related Articles:
 Classes and Objects
 Inheritance
 Access Modifiers
 Abstraction

Learn to code easily with our course Coding for Everyone. This course is accessible and
designed for everyone, even if you're new to coding. Start today and join millions on a
journey to improve your skills!

Whether you're preparing for your first job interview or aiming to upskill in this ever-
evolving tech landscape, GeeksforGeeks Courses are your key to success. We provide
top-quality content at affordable prices, all geared towards accelerating your growth in a
time-bound manner. Join the millions we've already empowered, and we're here to do the
same for you. Don't miss out - check it out now!