Foro de elhacker.net

#include <iostream>
#include <conio.h>
#include <stdlib.h>
#include <string.h>
 
using namespace std;
 
int pedirNombre();
void contarVocales(char*,int);
void mostrarVocales();
 
int *p_a, *p_e, *p_i, *p_o, *p_u; // punteros de los contadores;
char *nombre;
 
int main(){
 
	contarVocales(nombre,pedirNombre());
	mostrarVocales();
 
 
 
	getch();
	return 0;
}
 
int pedirNombre(){
	int longitud;
	char usuario[30];
 
	cout<<"Digite su nombre: ";
	cin.getline(usuario,30,'\n');
	longitud = strlen(usuario);
 
	nombre = &usuario[0];	
 
	return longitud;
}
 
void contarVocales(char* nombre,int n){
	int c_a, c_e, c_i, c_o, c_u; //contador vocales;
 
	c_a = 0; 
	c_e = 0;
	c_i = 0;
	c_o = 0;
	c_u = 0;
 
	p_a = &c_a;
	p_e = &c_e;
	p_i = &c_i;
	p_o = &c_o;
	p_u = &c_u;
 
	for(int i=0;i<n;i++){
		switch(*(nombre+i)){
			case 'a': c_a++; break;
			case 'e': c_e++; break;
			case 'i': c_i++; break;
			case 'o': c_o++; break;
			case 'u': c_u++; break;	 
		}
	}	
}
 
void mostrarVocales(){
	cout<<"num. de a: "<<*p_a<<endl;
	cout<<"num. de e: "<<*p_e<<endl;
	cout<<"num. de i: "<<*p_i<<endl;
	cout<<"num. de o: "<<*p_o<<endl;
	cout<<"num. de u: "<<*p_u<<endl;
}

void contarVocales(char*,int); 

void contarVocales();

int pedirNombre();

int incrementar(int a){
    return ++a;
}
int a = 2;
int b = incrementar(a); 

int incrementar(int &a){
    return ++a;
}
int a = 2;
int b = incrementar(a); 

int incrementar(int *p){
    return ++(*p);
}
int a = 2:
int *pa = &a;
int b = incrementar(pa); 

• 5 variables por referencia declaradas en el <main> usadas como contadores.
• Un array de <int> de tamaño 5 que equivale a juntar las 5 variables de la otra opción en un array.

 
#include <iostream>
#include <stdlib.h>
#include <string.h>
 
using namespace std;
 
int pedirNombre(char&);
void contarVocales(int);
void mostrarVocales();
 
int *p_vocales; // punteros de los contadores;
char *nombre;
 
int main(){
	int c_vocales[5] ={0,0,0,0,0}, longitud;  //0 == a, 1 == b ... 4 == u;
	char usuario[30];
 
	nombre = &usuario[0];
	p_vocales = &c_vocales[0];
 
	longitud = pedirNombre(usuario[30]);
	contarVocales(longitud);
	mostrarVocales();
 
 
 
	cin.get();
	return 0;
}
 
int pedirNombre(char& us){
	int longitud;
 
	cout<<"Digite su nombre: ";
	cin.getline(us,30,'\n');
	longitud = strlen(us);
 
	return longitud;
}
 
void contarVocales(int n){
 
	for(int i=0;i<n;i++){
		switch(*(nombre+i)){
			case 'a': *(p_vocales+i) = *(p_vocales+i) + 1; break;
			case 'e': *(p_vocales+i) = *(p_vocales+i) + 1;; break;
			case 'i': *(p_vocales+i) = *(p_vocales+i) + 1;; break;
			case 'o': *(p_vocales+i) = *(p_vocales+i) + 1; break;
			case 'u': *(p_vocales+i) = *(p_vocales+i) + 1; break;	 
		}
	}
 
}
 
void mostrarVocales(){
	cout<<"num. de a: "<<p_vocales[0]<<endl;
	cout<<"num. de e: "<<p_vocales[1]<<endl;
	cout<<"num. de i: "<<p_vocales[2]<<endl;
	cout<<"num. de o: "<<p_vocales[3]<<endl;
	cout<<"num. de u: "<<p_vocales[4]<<endl;
}
 

#include <iostream>
#include <stdlib.h>
#include <string.h>
 
using namespace std;
 
int pedirNombre();
void contarVocales(int);
void mostrarVocales();
 
int *p_vocales; // punteros de los contadores;
char *nombre;
 
int main(){
	int c_vocales[5] ={0,0,0,0,0}, longitud;  //0 == a, 1 == b ... 4 == u;
	p_vocales = &c_vocales[0];
 
	longitud = pedirNombre();
	contarVocales(longitud);
	mostrarVocales();
 
 
	cout<<"\n"<<nombre<<endl;
 
	cin.get();
	return 0;
}
 
int pedirNombre(){
	int longitud;
 
	cout<<"Digite su nombre: ";
	nombre = new char[30];
	cin.getline(nombre,30,'\n');
	longitud = strlen(nombre);
 
	return longitud;
}
 
void contarVocales(int n){
 
	for(int i=0;i<n;i++){
		switch(nombre[i]){
			case 'a': *(p_vocales) = *(p_vocales) + 1; break;
			case 'e': *(p_vocales+1) = *(p_vocales+1) + 1; break;
			case 'i': *(p_vocales+2) = *(p_vocales+2) + 1; break;
			case 'o': *(p_vocales+3) = *(p_vocales+3) + 1; break;
			case 'u': *(p_vocales+4) = *(p_vocales+4) + 1; break;	 
		}
	}
}
 
void mostrarVocales(){
	cout<<"num. de a: "<<p_vocales[0]<<endl;
	cout<<"num. de e: "<<p_vocales[1]<<endl;
	cout<<"num. de i: "<<p_vocales[2]<<endl;
	cout<<"num. de o: "<<p_vocales[3]<<endl;
	cout<<"num. de u: "<<p_vocales[4]<<endl;
}

case 'a': *(p_vocales+i) = *(p_vocales+i) + 1; break;

case 'a': *(p_vocales) ++; break;

case 'a': *(p_vocales) += 1; break;

int pedirNombre(char*); 

longitud = pedirNombre(usuario); 

• Como antes te he comentado, hay que evitar las variables globales. Por tanto no deberíamos tener las líneas 12 y 13. El nombre de un array corresponde a un puntero que apunta a la primera posición del array. En tu caso:

// creamos un array de <int>
int vocales[5] = {0}; // Con esto se inicializa la primera posicion al valor que indiques y el resto a 0 por lo tanto todo a 0
int *puntero = &vocales[0]; // hacemos que <puntero> apunte al comienzo de <vocales>
// Ahora tenemos dos punteros que apuntan a <vocales[0]>. Uno es <puntero> y el otro es <vocales> (<vocales> equivale a <&vocales[0]> por lo que podemos hacer:)
int *puntero = vocales; // esto equivale a lo anterior
// O directamente podemos usar <vocales> y nos ahorramos un puntero global que no nos traera nada bueno 

• La aritmética de puntero no es lo más cómodo digamos. Por lo tanto a no ser que te lo exijan o te guste, puedes usar la indexación:

vocales[i]
*(vocales+i) 

int vocales[5] = {1,2,3,4,5};
int *puntero = vocales;
++puntero; // ahora <puntero> apunta a la siguiente posicion
++(*puntero); // ahora incrementamos el valor al que apunta <puntero> que es <vocales[1]> entonces <vocales> = {1,3,3,4,5}
++(*(puntero+1)); // incrementamos el valor de la siguiente posicion a la que apunta <puntero>. Ahora <vocales> = {1,3,4,4,5} 

• Crear el array <char nombre[30]> en el <main>
• Crear el array <int vocales[5]> en el <main>
• Usar una función <int pedirNombre(char *nombre)> para pedir el nombre al usuario y obtener su longitud.
• Usar una función <void contarVocales(char *nombre, int longitud, int *vocales)> para contar las vocales.

#include <iostream>
#include <stdlib.h>
#include <string.h>
 
using namespace std;
 
int pedirNombre(char*);
void contarVocales(char*,int,int*);
void mostrarVocales(int*);
 
 
int main(){
	int c_vocales[5] ={0,0,0,0,0}, longitud;  //0 == a, 1 == b ... 4 == u;
	char nombre[30];
 
	longitud = pedirNombre(nombre);
	contarVocales(nombre,longitud,c_vocales);
	mostrarVocales(c_vocales);
 
 
	cout<<"\n"<<nombre<<endl;
 
	cin.get();
	return 0;
}
 
int pedirNombre(char* nombre){
	int longitud;
 
	cout<<"Digite su nombre: ";
 
	cin.getline(nombre,30,'\n');
	longitud = strlen(nombre);
 
	return longitud;
}
 
void contarVocales(char*nombre,int n,int*p_vocales){
 
	for(int i=0;i<n;i++){
		switch(nombre[i]){
			case 'a': *(p_vocales) = *(p_vocales) + 1; break;
			case 'e': *(p_vocales+1) = *(p_vocales+1) + 1; break;
			case 'i': *(p_vocales+2) = *(p_vocales+2) + 1; break;
			case 'o': *(p_vocales+3) = *(p_vocales+3) + 1; break;
			case 'u': *(p_vocales+4) = *(p_vocales+4) + 1; break;	 
		}
	}
}
 
void mostrarVocales(int* vocales){
	cout<<"num. de a: "<<vocales[0]<<endl;
	cout<<"num. de e: "<<vocales[1]<<endl;
	cout<<"num. de i: "<<vocales[2]<<endl;
	cout<<"num. de o: "<<vocales[3]<<endl;
	cout<<"num. de u: "<<vocales[4]<<endl;
}

• es la posición de memoria de la posición v[0] del vector?

• es un puntero del vector que se llama nombre y esta en la posición v[0] del vector con su mismo nombre?.

void funcion1(int a); // variable por valor
void funcion2(int &a); // variable por referencia
void funcion3(int *pa); // puntero por valor
void funcion4(int *&pa); // puntero por referencia 

int numeros[5] = {1,2,3,4,5};
// aqui podemos usar <numeros> como si fuera un puntero que apunta a &numeros[0]
// por lo tanto podemos hacer cosas como:
cout << *numeros << endl; // imprime: 1
for(size_t i = 0; i < 5; ++i)
    cout << *(numeros+i) << " " << endl; // imprime: 1 2 3 4 5 

void recorrerVector1(int *numeros, int longitud){
    for(int i = 0; i < longitud; ++i)
        cout << *(numeros+i) << endl;
}
 
void recorrerVector2(int *numeros, int longitud){
    for(int i = 0; i < longitud; ++i){
        cout << *numeros << endl;
        ++numeros;
    }
} 

int numeros[5] = {1,2,3,4,5};
int *puntero = numeros;
recorrerVector2(puntero, 5); // aqui no hay problemas porque aunque <puntero> se mueva, <numeros> siempre apunta al comienzo del vector
//en cambio si hacemos esto...
recorrerVector2(numeros, 5); // ... adios al vector. Ya no hay forma de volver a usarlo ni de liberarlo si fuera memoria dinamica 

int pedirNombre(char& us){
	int longitud;
 
	cout<<"Digite su nombre: ";
	cin.getline(us,30,'\n');
	longitud = strlen(us);
 
	return longitud;
} 

void funcion1(int a){
    cout << "La variable vale: " << a << " y su direccion de memoria es: " << &a << endl;
    // Se muestra la direccion de memoria de la copia
    // IMPORTANTE: el valor se obtiene con el nombre tal cual y la direccion con &
}
 
void funcion2(int &a){
    cout << "La variable vale: " << a << " y su direccion de memoria es: " << &a << endl;
    // Se muestra la direccion de memoria de la original
    // IMPORTANTE: el valor se obtiene con el nombre tal cual y la direccion con &
}
 
void funcion3(int *pa){
    cout << "La variable vale: " << *pa << " y su direccion de memoria es: " << pa << endl;
    // Se muestra la direccion de memoria de la original pero no de <pa> sino a la que apunta <pa>
    // IMPORTANTE: el valor se obtiene con * y la direccion con el nombre tal cual
}
 
// USO DE LAS FUNCIONES
int numero = 2;
funcion1(numero); // se pasa un <int>
funcion2(numero); // se pasa un <int> aunque el programa ya sabe que es por referencia
funcion3(numero); // ERROR: El programa espera una direccion de memoria (puntero) y le estamos pasando un <int>
funcion3(&numero); // Correcto: Le pasamos una direccion de memoria sin crear un puntero auxiliar (que tambien se podria hacer)
 

int pedirNombre(char *nombre){
    cout << "Introduce nombre: ";
    cin.getline(nombre, 30, '\n');
    return strlen(nombre);
}
 
// USO DE LA FUNCION
int longitud = pedirNombre(nombre); // Como hemos visto antes tiene que recibir directamente la direccion de memoria, bien asi o bien asi:
int longitud = pedirNombre(&nombre[0]); // que es exactamente lo mismo 

int pedirNombre(char &nombre){
    cout << "Introduce tu nombre: ";
    cin.getline(&nombre, 30, '\n');
    return strlen(&nombre);
}
// o bien:
int pedirNombre(char &nombre){
    char *puntero = &nombre;
    cout << "Introduce nombre: ";
    cin.getline(puntero, 30, '\n');
    return strlen(puntero);
}
 
// USO DE LA FUNCION
int longitud = pedirNombre(nombre[0]); // como hemos visto antes se pasa la variable y ya el programa sabe que tiene que usar su direccion de memoria 

#include <iostream>
#include <cstring>
 
using namespace std;
 
void pedirNombre1(char*);
void pedirNombre2(char*);
void pedirNombre3(char&);
void contadorVocales1(char*);
void contadorVocales2(char*);
void contadorVocales3(char&);
 
 
int main(){
	char nombre1[30], *p_nombre;
	char nombre2[30];
	char nombre3[30]; 
 
	p_nombre = &nombre1[0];
 
	pedirNombre1(p_nombre);
	pedirNombre2(nombre2);
	pedirNombre3(nombre3[0]);
	contadorVocales1(p_nombre);
	contadorVocales2(nombre2);
	contadorVocales3(nombre3[0]);
 
 
	cin.get();
	return 0;
}
 
void pedirNombre1(char *p_nombre){
	cout<<"Ej.1 -- Digite una frase: ";
	cin.getline(p_nombre,30,'\n');
}
 
void pedirNombre2(char *daigual2){
	cout<<"\nEj.2 -- Digite una frase: ";
	cin.getline(daigual2,30,'\n');
}
 
void pedirNombre3(char &daigual3){
	cout<<"\nEj.3 -- Digite una frase: ";
	cin.getline(&daigual3,30,'\n');
}
 
void contadorVocales1(char* p_daigual){
 
	cout<<"\n------------------------------------------------------";
	cout<<"\nEj.1 -- La frase digitada es: "<<p_daigual<<". En la direccion: "<<*p_daigual;
 
}
 
void contadorVocales2(char* daigual){
 
	cout<<"\n------------------------------------------------------";
	cout<<"\nEj.1 -- La frase digitada es: "<<daigual<<". En la direccion: "<<*daigual;
 
}
 
void contadorVocales3(char& daigual){
 
	cout<<"\n------------------------------------------------------";
	cout<<"\nEj.1 -- La frase digitada es: "<<&daigual<<". En la direccion: "<<daigual;
 
}

char nombre[] = {'a','b','c'}, *p_nombre2;
cout<<"Dir.1: "<<nombre[1]<<" | "<<p_nombre2<<endl;
 
//Salida: Dir.1: b | abc

int nombre[] = {1,2,3}, *p_nombre2;
cout<<"Dir.1: "<<nombre[1]<<" | "<<p_nombre2<<endl;
//Salida: Dir.1: 2 | 0x6ffdf0 

int nombre[] = {1,2,3}, *p_nombre2;
cout<<"Dir.1: "<<nombre[1]<<" | "<<p_nombre2<<endl;
//Salida: Dir.1: 2 | 0x6ffdf0 

char nombre[] = {'a','b','c'}, *p_nombre2;
cout<<"Dir.1: "<<nombre[1]<<" | "<<p_nombre2<<endl;
//Salida: Dir.1: b | abc 

for(int i = 0; i < size; ++i)
    cout << arrayEnteros[i] << " "; 

char nombre[] = "Pepe";
cout << "Tu nombre es: ";
for(int i = 0; i < 4; ++i)
    cout << nombre[i]; 

char nombre[] = "Pepe";
cout << "Tu nombre es: " << nombre << endl; 

string nombre = "Pepe";
cout << "La primera letra de " << nombre << " es: " << nombre[0] << endl; 

#include <iostream>
#include <cstdlib>
using namespace std;
 
void pedirDatos(int**,int&,int&);
void imprimirDatos(int**,int,int);
 
int **p_m2;
 
int main(){
	int **p_m,fil,col;
 
	pedirDatos(p_m,fil,col);
	//imprimirDatos(p_m,fil,col); No funciona, se para al mostrar la matriz
	cout<<*(*(p_m2+1)+1); //tampoco va, ahora se corta al insertar las variabes
 
	//liberar memoria;
	for(int i=0;i<fil;i++){
		delete[] p_m[i];
	}
 
	delete[] p_m;
 
	cin.get();
	return 0;
}
 
void pedirDatos(int** p_m,int &fil,int &col){
	cout<<"Digite numero de Filas: ";
	cin>>fil;
	cout<<"Digite numero de Columnas: ";
	cin>>col;
 
	//Reservar memoria para matriz dinámica.
	p_m2 = new int*[fil]; //Reservando memoria para las filas.
	for(int i=0;i<fil;i++){
		p_m2[i] = new int[col]; //Reservando memoria para columnas
	}
 
	cout<<"\nDigite elementos matriz: "<<endl;
	for(int i=0;i<col;i++){
		for(int j=0;j<fil;j++){
			cout<<"Digite un numero ["<<i<<"]["<<j<<"]: ";
			cin>>*(*(p_m+i)+j);
		}
	}
 
	//Comprobar si lo ha grabado bien:
	for(int i=0;i<fil;i++){
		for(int j=0;j<col;j++){
			cout<<*(*(p_m+i)+j);
		}
		cout<<"\n";
	}//funciona, edit: despues de tocarlo todo 3000 veces ya no xD.
}
 
void imprimirDatos(int** p_m,int f,int c){
	cout<<"\n------------------------------------\nLa matriz es: "<<f<<"x"<<c<<"\n\n";
	cout<<*(*(p_m+1)+1); //Tambien se traba a intentar imprimirlo
	/*for(int i=0;i<f;i++){
		for(int j=0;j<c;j++){
			cout<<*(*(p_m+i)+j);
		}
		cout<<"\n";
	}*/
}

void pedirDatos(int** p_m,int &fil,int &col){
	int f,c;
 
	cout<<"Digite numero de Filas: ";
	cin>>f;
	cout<<"Digite numero de Columnas: ";
	cin>>c;
	cout<<f<<c<<endl; //Comprobar que guarde bien
	//Reservar memoria para matriz dinámica.
	p_m2 = new int*[f]; //Reservando memoria para las filas.
	for(int i=0;i<fil;i++){
		p_m2[i] = new int[c]; //Reservando memoria para columnas
	}
 
	cout<<"\nDigite elementos matriz: "<<endl;
	for(int i=0;i<c;i++){
		for(int j=0;j<f;j++){
			cout<<"Digite un numero ["<<i<<"]["<<j<<"]: ";
			cin>>*(*(p_m+i)+j);
		}
	}

• Opcion 1: Reservar memoria en el <main> y pasar el doble puntero por valor (como lo estás pasando ahora).
• Opcion 2: Pasar el doble puntero por referencia y listo. Ya que has llegado hasta donde has llegado, te recomiendo esta segunda:

void pedirDatos(int**&, int&, int&); 

cout << *(*(matriz + i) + j) << endl; // aritmetica de punteros
cout << matriz[i][j] << endl; // indexacion 

#include <iostream>
#include <stdlib.h>
using namespace std;
 
void pedirDatos(int**&,int&,int&);
void imprimirDatos(int**,int,int);
 
int main(){
	int **p_m,fil,col;
 
	pedirDatos(p_m,fil,col);
	imprimirDatos(p_m,fil,col);
 
	//liberar memoria;
	for(int i=0;i<fil;i++){
		delete[] p_m[i];
	}
 
	delete[] p_m;
 
	cin.get();
	return 0;
}
 
void pedirDatos(int**& p_m,int &fil,int &col){
 
	cout<<"Digite numero de Filas: ";
	cin>>fil;
	cout<<"Digite numero de Columnas: ";
	cin>>col;
 
	//Reservar memoria para matriz dinámica.
	p_m = new int*[fil]; //Reservando memoria para las filas.
	for(int i=0;i<fil;i++){
		p_m[i] = new int[col]; //Reservando memoria para columnas
	}
 
	cout<<"\nDigite elementos matriz: "<<endl;
	for(int i=0;i<col;i++){
		for(int j=0;j<fil;j++){
			cout<<"Digite un numero ["<<i<<"]["<<j<<"]: ";
			cin>>*(*(p_m+i)+j);
		}
	}
}
 
void imprimirDatos(int** p_m,int f,int c){
	cout<<"\n------------------------------------\nLa matriz es: "<<f<<"x"<<c<<"\n\n";
	for(int i=0;i<f;i++){
		for(int j=0;j<c;j++){
			cout<<*(*(p_m+i)+j)<<" ";
		}
		cout<<"\n";
	}
}

#include <iostream>
 
using namespace std;
 
void pedirMatriz(int**&,int**&,int&,int&,int&,int&);
bool sumarMatriz(int**,int**,int**&,int,int,int,int);
void mostrarSuma(int**,int,int);
 
int main(){
	int **p_m1, **p_m2, c1, f1/*filas y columnas de la matriz dinámica 1*/, c2, f2;
	int **suma;
	bool coinciden;
 
	pedirMatriz(p_m1,p_m2,c1,f1,c2,f2);
	coinciden = sumarMatriz(p_m1,p_m2,suma,c1,f1,c2,f2);
 
	if (coinciden == true){
		mostrarSuma(suma,f1,c1);
 
		//Borrar memoria matriz suma (Solo si se crea)
		for(int i=0;i<f1;i++){
			delete[] suma[i];
		}
		delete[] suma;
	}
	else{
		cout<<"Las matrices no tienen las mismas dimensiones.";
	}
 
	//Borrar memoria M[1] y M[2];
	for(int i=0;i<f1;i++){
		delete[] p_m1[i];
	}
	delete[] p_m1;
 
	for(int i=0;i<f2;i++){
		delete[] p_m2[i];
	}
	delete[] p_m2;
 
	//Fin programa
	cin.get();
	return 0;
}
void pedirMatriz(int**& m1,int**& m2,int& f1,int& c1,int& f2,int& c2){
 
	cout<<"Digite num. de filas para M[1]: "; cin>>f1;
	cout<<"Digite num. de columnas para M[1]: "; cin>>c1;
	cout<<"\nDigite num. de filas para M[2]: "; cin>>f2;
	cout<<"Digite num. de columnas para M[2]: "; cin>>c2;
 
	//Revervar espacio puntero filas, ya que cada fila apunta al resto de columnas (Como un puntero de un vector encima de otro);
	m1 = new int*[f1];
 
	//Reservar espacio columnas;
	for(int i=0;i<f1;i++){
		m1[i] = new int[c1];
	}
 
	cout<<"\n-----------------------------------------"<<endl;
	cout<<"Digite los valores de M[1]: "<<endl;
 
	//Empezar recogida de datos M[1];
	for(int i=0;i<f1;i++){
		for(int j=0;j<c1;j++){
			cout<<"Valor de M1["<<i<<"]["<<j<<"]: ";
			cin>>*(*(m1+i)+j); //Equivale a m1[i][j]
		}
	}
 
	//Reservar espacio memoria M[2];
	m2 = new int*[f2];
 
	for(int i=0;i<f2;i++){
		m2[i] = new int[c2];
	}
 
	cout<<"\n-----------------------------------------"<<endl;
	cout<<"Digite los valores de M[1]: "<<endl;
 
		//Empezar recogida de datos M[1];
	for(int i=0;i<f2;i++){
		for(int j=0;j<c2;j++){
			cout<<"Valor de M2["<<i<<"]["<<j<<"]: ";
			cin>>m2[i][j]; //Equivale a *(*(m2+i)+j);
		}
	}	
}
 
bool sumarMatriz(int** m1,int** m2,int**& suma,int f1,int c1,int f2,int c2){
	bool coin;
 
	if(f1 == f2 && c1 == c2){
		//Crear matriz dinamica suma; uso f1 ya que f1 == f2, asi no creo mas variables;
		suma = new int*[f1];
 
		for(int i=0;i<f1;i++){
			suma[i] = new int[c1];
		}
 
		for(int i=0;i<f1;i++){
			for(int j=0;j<c1;j++){
				suma[i][j] = m1[i][j] + m2[i][j];
			}
		}
		coin = true;
	}
	else{
		coin = false;
	}
 
	return coin;
}
 
void mostrarSuma(int** suma,int f1, int c1){
 
	cout<<"\n-----------------------------------------"<<endl;
	cout<<"La suma de las 2 matrices es: "<<endl;
 
	for(int i=0;i<f1;i++){
		for(int j=0;j<c1;j++){
			cout<<suma[i][j]<<" "; //Es lo mismo que usar: *(*(suma+i)+j);
		}
		cout<<endl;
	}
}

for(int i = 0; i < filas; ++i){
    for(int j = 0; j < columnas; ++j)
        cout << *(*matriz + i) + j) << " ";
    cout << endl;
} 

for(int i = 0; i < columnas; ++i){
    for(int j = 0; j < filas; ++j)
        cout << *(*matriz + i) + j) << " ";
    cout << endl;
} 

int numero = 2; // pongamos que se guarda en 0x1 (voy a usar numeros cortos para que sea mas sencillo)
cout << "Numero vale: " << numero << " y su direccion de memoria original es: " << &numero << endl;
// Salida: Numero vale: 2 y su direccion de memoria original es: 0x1
 
// Pasamos la variable por referencia para pasar la direccion de memoria en la que esta guardado <numero> (0x1)
void incrementar(int &numero){ // pasamos 0x1
    ++numero;
    cout << "Numero vale: " << numero << " y su direccion de memoria ORIGINAL es: " << &numero << endl;
}
// Salida: Numero vale: 3 y su direccion de memoria ORIGINAL es: 0x1
 
int *p_numero = &numero; // pongamos que <p_numero> se guarda en 0x5 y dentro de 0x5 guarda la direccion de <numero> 0x1
// Pasamos un puntero por valor, entonces estamos haciendo una copia de su contenido pero su contenido ya es la direccion de memoria de <numero> 0x1
void incrementar(int *p_numero){ // a la funcion llega 0x1 y se guarda en una copia del puntero en 0x13 por ejemplo
    ++(*p_numero);
    cout << "Numero vale: " << *p_numero << " y su direccion de memoria ORIGINAL es " << p_numero << endl;
    cout << "La direccion de memoria del puntero es: " << &p_numero << endl;
}
// Salida: Numero vale: 4 y su direccion de memoria ORIGINAL es: 0x1
//         La direccion de memoria del puntero es: 0x13 // Aqui se ve la direccion de la copia, no 0x5
 
// Pasamos el puntero por referencia, entonces estamos pasando la direccion de memoria EN LA QUE ESTA EL PUNTERO (0x5), no a la que apunta (<numero>)
void incrementar(int *&p_numero){ // a la funcion llega 0x5 que sigue apuntando a 0x1
    ++(*p_numero);
    cout << "Numero vale: " << *p_numero << " y su direccion de memoria ORIGINAL es " << p_numero << endl;
    cout << "La direccion de memoria del puntero ORIGINAL es: " << &p_numero << endl;
}
// Salida: Numero vale: 5 y su direccion de memoria ORIGINAL es: 0x1
//          La direccion de memoria del puntero ORIGINAL es: 0x5
} 

void funcion(int**& p_m) // usando new 
//seria equivalente a:
void funcion(int m[][100]

void funcion(int**& p_m) // usando new 
//seria equivalente a:
void funcion(int m[][100] 

void funcion1(int **matriz); // pasamos la direccion de memoria del elemento [0][0]
void funcion2(int **&matriz); // pasamos la direccion de memoria que apunta a la direccion de memoria del elemento [0][0]
void funcion3(int matriz[][TAM]); // igual que funcion1() pero necesitamos indicar todas las dimensiones excepto la primera
void funcion4(int &matriz[][TAM]); // igual que funcion2() pero indicando las dimensiones como en la funcion3() 

int miArray[5]; 

int *miArray = new int[5]; 

int *miArray = new int[10];
int *otroArray = new int[5];
// Queremos intercambiarlos pero en cuanto asignemos algo a uno de esos punteros, perderemos el array entonces:
int *auxiliar = miArray; // Ahora el primer array tiene dos nombres: <auxiliar> y <miArray>
miArray = otroArray; // Ahora hacemos que el puntero <miArray> apunte al mismo sitio que <otroArray>
otroArray = auxiliar; // Y ahora <otroArray> apunta al mismo sitio que <auxiliar> que era el array original al que apuntaba <miArray> 

delete [] auxiliar; 

void incrementar(void *puntero, int size){
    if(size == sizeof(char)){
        char *p_char = (char*)puntero;
        ++(*p_char);
    }
    if(size == sizeof(int)){
        char *p_int = (int*)puntero;
        ++(*p_int);
    }
}
 
int main(){
    char letra = 'a';
    int numero = 1;
    incrementar(&letra, sizeof(letra));
    incrementar(&numero, sizeof(numero));
    cout << letra << " - " << numero << endl;
} 

Salida: b - 2 

int sumar(int a, int b){
    return a + b;
}
 
int restar(int a, int b){
    return a - b;
}
 
int realizarOperacion(int (*operacion)(int,int), int a, int b){
    int resultado = (*operacion)(a,b);
    return resultado;
}
 
int main(){
    int a = 4, b = 1;
    int (*realizarResta)(int,int) = restar;
    int resultadoSuma = realizarOperacion(sumar, a, b);
    int resultadoResta = realizarOperacion(realizarResta, resultadoSuma, b);
} 

#include <iostream>
 
using namespace std;
 
void pedirDatos(int**&,int**&,int&,int&,int&,int&);
void multiplicarMatrices(int**,int**,int**&,int,int,int);
int multi(int**,int**,int,int,int);
void mostrarMatriz(int**,int,int);
 
int main(){
	int **m1,**m2,c1,f1,c2,f2;
	int **mMultiplicacion;
 
	pedirDatos(m1,m2,f1,c1,f2,c2);
	multiplicarMatrices(m1,m2,mMultiplicacion,f1,c2,c1); //c1 == f2 == c_f; 
	mostrarMatriz(mMultiplicacion,f1,c2);
 
 
 
	cin.get();
	return 0;
}
 
void pedirDatos(int**& m1, int**& m2, int& f1, int& c1, int& f2, int& c2){
 
	//Repetir proceso hasta que las dimensiones de las matrices sean multiplicables;
	do{
	//Definir filas y columnas M[1];
	cout<<"Digite numero de filas de M[1]: "; cin>>f1;
	cout<<"Digite numero de columnas de M[1]: "; cin>>c1;
 
	//Definir filas y columnas M[2];
	cout<<"\nDigite numero de filas de M[2]: "; cin>>f2;
	cout<<"Digite numero de columnas de M[2]: "; cin>>c2;
 
	cout<<"\n\n";}
	while(c1 != f2);
	//M[f1][c1] * T[f2][c2] |([c1] == [f2])| ---> = R[f1][c2];
 
	//Reservar memoria para matriz puntero m1;
	m1 = new int*[f1];
	for(int i=0;i<f1;i++){
		m1[i] = new int[c1];
	}
 
	m2 = new int*[f2];
	for(int i=0;i<f2;i++){
		m2[i] = new int[c2];
	}
 
	//Declarar variables matriz 1;
	for(int i=0;i<f1;i++){
		for(int j=0;j<c1;j++){
			cout<<"Digite valor de M1["<<i<<"]["<<j<<"]: ";
			cin>>m1[i][j]; //es lo mismo que *(*(m1+i)+j);
		}
	}
	cout<<endl;
 
	//Declarar variables matriz 2;
	for(int i=0;i<f2;i++){
		for(int j=0;j<c2;j++){
			cout<<"Digite valor de M2["<<i<<"]["<<j<<"]: ";
			cin>>m2[i][j];
		}
	}
	cout<<endl;
}
 
void multiplicarMatrices(int** m1,int** m2,int**& mT,int f,int c, int f_c){
 
	//Reservar memoria mT;
	mT = new int*[f];
	for(int i=0;i<f;i++){
		mT[i] = new int[c];
	}
 
	//Empezar multiplicación;
	for(int i=0;i<f;i++){
		for(int j=0;j<c;j++){
			mT[i][j] = multi(m1,m2,f_c,i,j); 
		}
	}	
 
}
 
int multi(int** m1,int** m2,int f_c, int x, int y){
	int total=0;
 
	//Multiplica filas M[1] x columnas M[2]. Maximo de multiplicaciones: c1 == f2 == f_c == c2_f1. Si es 2x3 * 3x3 --> multiplica máximo 3 veces --> MTotal = 2x3;
	for(int i=0;i<f_c;i++){
		total += (m1[x][i] * m2[i][y]);
	}
 
 
	return total;
}
 
void mostrarMatriz(int** m,int f,int c){
 
	//Mostrar Matriz Total
	cout<<"\n-----------------------------------------\n";
	cout<<"La Matriz total es:\n";
	for(int i=0;i<f;i++){
		for(int j=0;j<c;j++){
			cout<<m[i][j]<<" ";
		}
		cout<<endl;
	}
}

void ordenarAscendente(int *numeros, int size){
    for(size_t i = 1; i < size; ++i)
        for(size_t j = 0; j < size-i; ++j)
            if(numeros[j] > numeros[j+1]){
                numeros[j] += numeros[j+1];
                numeros[j+1] = numeros[j] - numeros[j+1];
                numeros[j] -= numeros[j+1];
            }
}
 
void ordenarDescendente(int *numeros, int size){
    for(size_t i = 1; i < size; ++i)
        for(size_t j = 0; j < size-i; ++j)
            if(numeros[j] < numeros[j+1]){
                numeros[j] += numeros[j+1];
                numeros[j+1] = numeros[j] - numeros[j+1];
                numeros[j] -= numeros[j+1];
            }
} 

bool mayor(int a, int b){
    return a > b;
}
 
bool menor(int a, int b){
    return a < b;
}
 
void ordenar(int *numeros, int size, bool (*orden)(int,int)){
    for(size_t i = 1; i < size; ++i)
        for(size_t j = 0; j < size-i; ++j)
            if(!orden(numeros[j], numeros[j+1])){
                numeros[j] += numeros[j+1];
                numeros[j+1] = numeros[j] - numeros[j+1];
                numeros[j] -= numeros[j+1];
            }
} 

for(int i=0;i<size;i++){
	for(int j=0;j<size;j++){
        //Aqui el ordenamineto burbuja
        }
}