Sólo se dos de esas cosas:

FUNCIONES AMIGAS:

Son aquellas que te permiten acceder a partes privadas de una clase sin necesidad de ser declaradas dentro de la clase.

Un intento de acceso a un dato privado de una clase te dará error:

#include <iomanip>
	class Ensayo
	{
		public:
			Ensayo();
			int datos_public;
		private:
			int datos_private;
	};
Ensayo::Ensayo(){
	datos_public = 10;
	datos_private = 25;
}
int main(){
 
	Ensayo objeto();
	cout << "Datos publicos: " << Ensayo.datos_public << '\n';
	cout << "Datos privados: " << Ensayo.datos_private << '\n'; // LINEA PROBLEMATICA
 
	return EXIT_SUCCESS;
}
 

Este código veras que intenta acceder a la parte privada de la clase, datos_private. No te compilará, te dará un error como:


Ahora, creemos lo siguiente: Una función externa con la cual podamos acceder a los datos internos de la clase, sin necesidad de hacerla parte de la clase.

#include <iostream>
	class Ensayo
	{
		friend int amiga( Ensayo & ); // CREAMOS UNA FUNCION , LE AGREGAMOS "FRIEND" AL INICIO.
		public:
			Ensayo( void );
			int datos_public;
		private:
			int datos_private;
	};
Ensayo::Ensayo( void ){
	datos_public = 10;
	datos_private = 25;
}
// LA FUNCION AMIGA ESTA DENTRO DEL MARCO GLOBAL, NO DEBO ANTEPONER "Ensayo::" A SU DECLARACION.
int amiga ( Ensayo & objeto ){
	return objeto.datos_private;
}
int main(){
 
	Ensayo objeto;
 
	std::cout << "Datos publicos: " << objeto.datos_public << '\n';
	std::cout << "Datos privados: " << amiga(objeto) << '\n';
 
	return EXIT_SUCCESS;
}

Lo que hicimos fue, dentro de la clase, crear una función amiga() que recibe como parámetro cualquier objeto de tipo Ensayo, y devuelve su parte privada. De esta manera tenemos una clase que nos permite leer la parte privada de la clase, sin necesidad de hacerla miembro de la clase.

POLIMORFISMO

Polimorfismo es la capacidad de declarar una funcion con más de una serie de parámetros distinto.
Por ejemplo, imaginate como funciona el operador de salida "cout" en C++. A veces tu le pasas un entero, otras veces un float, otras una cadena, ¿cómo hace para saber como debe procesar cada valor? Pues muy simple, hay toda una lista de funciones declaradas para cada uno de estos valores.

Digamos que tu tienes una funcion llamada "imprimir"; y quieres que, al pasarle un entero como parametro, esta funcion imprima "Tu numero es tal", y que en cambio, al pasarle una cadena, te imprima "Has dicho la frase tal". Para esto, lo único que debes hacer es crear dos funciones con una lista de parámetros diferente.

#include <iostream>
#include <string>
using std::string;
using std::cout;
 
void imprimir ( int a ){
	cout << "Has dicho el numero " << a << '\n';
	}
void imprimir ( string f ){
	cout << "Has dicho la frase " << f << '\n';
}
 
int main(){
 
	int numero = 17;
	string frase = "Bienvenido a casa";
 
	imprimir(numero);
	imprimir(frase);
 
	return EXIT_SUCCESS;
}

La salida es:


¿Ves? Las dos funciones se llaman igual, pero según el parámetro que le pases, actuará una o la otra. Si le pasas un entero, actuará la primera, y si le pasas una cadena, actuará la segunda.

Si tienes dudas, o quieres más ejemplos, no dudes en preguntar

Ja ja, tienes razón Freak. Vaya error de conceptos

Buenas

Lamento decirte que tambien estas errado Anibal784. Los metodos virtuales no es lo que posibilitan el polimorfismo.

Aca les dejo un codigo de muestra.

#include <iostream>
#include <cstdlib>
 
class claseA 
{
	public:	
		void print() {
			std::cout << "-- Soy de clase A --" << std::endl;	
		}
 
		virtual void print2() {
			std::cout << "-- Soy de clase A --" << std::endl;	
		}
};
 
class claseC : public claseA 
{
	public:	
		void print() {
			std::cout << "-- Soy de clase C --" << std::endl;	
		}
 
		void print2() {
			std::cout << "-- Soy de clase C --" << std::endl;	
		}		
 
};
 
class claseB 
{
	public:	
		void print() {
			std::cout << "-- Soy de clase B --" << std::endl;	
		}
};
 
void xprint(claseA *);
void xprint2(claseA *);
 
int main(void)
{
	claseA    a;
	claseB	  b;
	claseC    c;
	std::cout << "Polimorfismo" << std::endl;
	a.print();
	b.print();
	c.print();
	std::cout << "----------------------------------" << std::endl;
	std::cout << "Funciones virtuales" << std::endl;
	std::cout << "Sin virtual" << std::endl;
	xprint(&a);
	xprint(&c);
	std::cout << "Con virtual" << std::endl;
	xprint2(&a);
	xprint2(&c);
 
	system("pause");
	return 0;	
}
 
void xprint(claseA *clase)
{
	clase->print();
}
 
void xprint2(claseA *clase)
{
	clase->print2();
}

A ver quien dice que posibilita las funciones virtuales...


Salu2, FreakMind

Buenas

No creo que sea hilar tan fino, y digamos que si estamos programando en C++, dependemos de C++

No solo el mismo nombre. claseA, claseB y claseC tienen el metodo print con la misma FIRMA (eso si mal no recuerdo incluye ademas del nombre, el valor de retorno y parametros).

Sobrecarga hubiera sido si le hubiera agregado algun parametro a print o le hubiera cambiado el valor de retorno

No esta mal, justamente lo hice para que vean esa diferencia.

Obvio que no podes usar xprint y xprint2 con claseB. Estas funciones esperan un claseA *. Si queres usar esos metodos tambien con claseB, tenes que usar Templates

Ya respondi arriba esto.

Polimorfismo no implica tiempo sino la capacidad de 2 o mas objetos de responder a un mismo mensaje.

Para hacer algo parecido a polimorfismo tenes que hacer bastante trabajo en C jeje.

Justamente, eso que explicaste es lo que posibilita las funciones virtual que no es polimorfismo sino algo llamado "binding dinamico"

Salu2, FreakMind