El camnio de c++ es largo, pero se sigue avanzando. Veamos las funciones inline, un recurso interesante para mejorar el rendimiento. 
/**
* Inline.cpp
* Programa para probar funciones Inline
* Las funciones Inline no se compilan como funciones aparte,
* lo que se hace al compilar es añadir el contenido de la funcion haya
* donde se se invoca. Con lo que es mucho mas rapido de ejecutar
* y ademas nos da la limpieza de separar el codigo.
*
* Pello Xabier Altadill Izura
*
* Compilado: g++ Inline.cpp -o Inline
*/

#include <iostream.h>

// las funciones en CPP las debemos declarar antes de invocar
// aqui tenemos el prototipo. Si no se pone tendremos ERROR de compilador

// Declaramos la funcion como inline
inline double Calcula (double a, double b);

// Log : saca un mensaje por pantalla
void Log(char *mensaje);

// Variables globales
long variable = 666;
char *PROGRAMA = "Globales> ";
int main () {

	// Sacamos por salida standar  un mensaje
 	Log("Vamos a probar los operadores");

	unsigned int test = 0;
	double a = 23, b = 21, c = 34;

	// Tomamos el valor a
	Log("Dame valores.
a=");
	cin >> a;

	// Tomamos el valor b
	cout << "b=";
	cin >> b;

	cout << "Y ahora son estos: b=" << b << " a="
<< a << " global:" << variable <

Paso de parametros

Vamos a ver formas de pasar parametros.


/**
* Parametros.cpp
* Programa para probar los parametros de las funciones y
* la forma de aplicar valores por defecto
*
* Pello Xabier Altadill Izura
*
* Compilado: g++ Parametros.cpp -o Parametros
*/

#include <iostream.h>

// las funciones en CPP las debemos declarar antes de invocar
// aqui tenemos el prototipo. Si no se pone tendremos ERROR de compilador
double Calcula (double a, double b);

// Log : saca un mensaje por pantalla
void Log(char *mensaje = "Sin valor prefijado");

// suma: suma dos valores
int Suma(int a = 0, int b = 0, int c = 0);

// Variables globales
long variable = 666;
char *PROGRAMA = "Globales> ";
int main () {

	// Sacamos por salida standar  un mensaje
 	Log("Vamos a probar los operadores");

	// Llamada sin parametros
	Log();

	unsigned int test = 0;
	int a = 23, b = 21, c = 34, d = 0;

	// Llamanda sin parametros
	d = Suma();
	cout << "Y el resultado de la funcion Suma sin parametros :" << d << endl;

	// Llamada con parametros
	d = Suma(a,b,c);
	cout << "Y el resultado de la funcion Suma :" << d << endl;

	// Probamos la funcion
	Log("Venga va vamos");

	return 0;
}

/**
* Calcula
* parametros: double a, double b
* devuelve: double
*/
double Calcula (double a, double b) {
	return (a / b) * variable;
}

/**
* Log
* parametros: char *mensaje
* devuelve: void
* NOTA: no hace falta volver a poner el valor prefijado
*/
void Log (char *mensaje) {
	cout << PROGRAMA << mensaje << endl;
}

/**
* Suma
* parametros: int a, int b, int c
* devuelve: int
*/
int Suma (int a = 0, int b = 0, int c = 0) {

	Log("Vamos a ver. Estamos en suma. ");

	// Devolvemos un valor
	return (a + b + c);
}



Sobrecarga de funciones
La sobrecarga es otro concepto básico en la POO. Aqui se muestra un boton.


/**
* Sobrecarga.cpp
* Programa para probar la sobrecarga de funciones
* La sobrecarga es una misma funcion con distintos parametros
* Con la sobrecarga logramos el POLIMORFISMO de clases y funciones
*
* Pello Xabier Altadill Izura
*
* Compilado: g++ Sobrecarga.cpp -o Sobrecarga
*/

#include <iostream.h>

// las funciones en CPP las debemos declarar antes de invocar
// aqui tenemos el prototipo. Si no se pone tendremos ERROR de compilador
double Calcula (double a, double b);

int Calcula (int a, int b);

float Calcula (float a, float b);

// Log : saca un mensaje por pantalla
// Esto provocaria error de compilador por ambiguedad de sobrecarga
//void Log();

// Log : saca un mensaje por pantalla
// NOTA: el valor por defecto solo se pone en la DECLARACION
void Log(char *mensaje = "Sin valor prefijado");

// suma: suma dos valores
int Suma(int a = 0, int b = 0, int c = 0);

// Variables globales
long variable = 666;
char *PROGRAMA = "Globales> ";
int main () {

	// Sacamos por salida standar  un mensaje
 	Log("Vamos a probar los operadores");

	// Llamada sin parametros
	Log();

	unsigned int test = 0;
	int a = 23, b = 21, c = 34, d = 0;

	// Llamanda sin parametros
	d = Suma();
	cout << "Y el resultado de la funcion Suma sin parametros :" << d << endl;

	// Llamada con parametros
	d = Suma(a,b,c);
	cout << "Y el resultado de la funcion Suma :" << d << endl;

	// Probamos la funcion
	Log("Venga va vamos");

	return 0;
}

/**
* Calcula
* parametros: double a, double b
* devuelve: double
*/
double Calcula (double a, double b) {
	return (a / b) * variable;
}

/**
* Calcula
* parametros: float a, float b
* devuelve: float
*/
float Calcula (float a, float b) {
	return (a / b) * variable;
}

/**
* Calcula
* parametros: long a, long b
* devuelve: long
*/
long Calcula (long a, long b) {
	return (a / b) * variable;
}

/**
* Log
* parametros: char *mensaje
* devuelve: void
*/
void Log (char *mensaje) {
	cout << PROGRAMA << mensaje << endl;
}

/**
* Suma
* parametros: int a, int b, int c
* devuelve: int
*/
int Suma (int a = 0, int b = 0, int c = 0) {

	Log("Vamos a ver. Estamos en suma. ");

	// Devolvemos un valor
	return (a + b + c);
}




El ambito


Hasta donde se identifica una variable?
Para saltarnos todas las vallas podemos usar variables globales.
No conviene abusar de este tipo de variables.


/**
* Globales.cpp
* Programa para probar variables y su scope
*
* Pello Xabier Altadill Izura
*
* Compilado: g++ Globales.cpp -o Globales
*/

#include <iostream.h>

// las funciones en CPP las debemos declarar antes de invocar
// aqui tenemos el prototipo. Si no se pone tendremos ERROR de compilador
double Calcula (double a, double b);

// Log : saca un mensaje por pantalla
void Log(char *mensaje);

// Variables globales
long variable = 666;
char *PROGRAMA = "Globales> ";
int main () {

	// Sacamos por salida standar  un mensaje
 	Log("Vamos a probar los operadores");

	unsigned int test = 0;
	double a = 23, b = 21, c = 34;

	// Tomamos el valor a
	Log("Dame valores.
a=");
	cin >> a;

	// Tomamos el valor b
	cout << "b=";
	cin >> b;

	cout << "Y ahora son estos: b=" << b
<< " a=" << a << " global:" << variable <