Mensajes

Tengo una duda.

Código (cpp) [Seleccionar] Expandir

void sacar(Nodo *&pila, int &n){
Nodo *aux = pila;
n = aux.dato;
pila = aux.siguiente;
delete aux;
}

aqui esta el main:

Código (cpp) [Seleccionar] Expandir

int main(){
Nodo *pila = NULL;
int dato;
char letra;

do{
cout<<"Digite un numero: ";
cin>>dato;
agregar(pila,dato);

do{
cout<<"\nDesea agregar otro elemento a la pila (Y/N): ";
cin>>letra;
letra = toupper(letra);
cout<<endl;
}while(letra != 'Y' && letra != 'N');

}while(letra == 'Y');

cout<<"\n\nSacando los elementos de la pila: ";

while(pila != NULL){
eliminar(pila,dato);

if(pila != NULL){
cout<<dato<<" , ";
}
else{
cout<<dato<<".\n\nYa se han eliminado todos los datos.";
}
}
cin.get();
return 0;
}

Por que hay que usar -> y no se puede usar "." como en:

Código (cpp) [Seleccionar] Expandir

#include <iostream>

using namespace std;

struct etapasCorredor{
int horas,minutos,segundos;
}nEtapas[3], *etapa = nEtapas;

void pedirDatos();
int calcularTiempo(int);
void mostrarTiempo(int);

int main(){
int cantidadEtapas = 3;

pedirDatos();
int totalTiempo = calcularTiempo(cantidadEtapas);
mostrarTiempo(totalTiempo);

cin.get();
return 0;
}

void pedirDatos(){

for(int i=0;i<3;i++){
cout<<"Digite tiempo de la etapa ["<<i<<"]: "<<endl;

cout<<"Horas: "; cin>>etapa[i].horas;
cout<<"Minutos: "; cin>>etapa[i].minutos;
cout<<"Segundos: "; cin>>etapa[i].segundos;

cout<<endl;
}

}

int calcularTiempo(int x){
int tiempo;

if(x == 0){
tiempo = etapa[x].horas*3600 + etapa[x].minutos*60 + etapa[x].segundos;
}
else{
tiempo = etapa[x].horas*3600 + etapa[x].minutos*60 + etapa[x].segundos + calcularTiempo(x-1);
}
//2-1-0 -->2 + 1 + 0;

return tiempo;
}

void mostrarTiempo(int tiempo){
int h,min,seg;

h = tiempo/3600;
min = (tiempo-h*3600)/60;
seg = tiempo-h*3600-min*60;

cout<<"\n---------------------------------\n\n";
cout<<"El tiempo total es: "<<endl;
cout<<"Horas: "<<h<<endl;
cout<<"Minutos: "<<min<<endl;
cout<<"Segundos: "<<seg<<endl;

}

PD: Por que siempre que el profesor usa valores como struct o variables globales en el paréntesis de la función (en este caso no hay variables globales pero en la mayoría del curso usa globales). Que diferencia hay con simplemente no ponerlas y usar el mismo código (en este caso lo entiendo por que al *pila estar dentro de la funcion main() si no pasamos el puntero por referencia despues de que acabe la funcion pila = nuevo_nodo se borraria y pila seguiria apuntando a NULL. Me refiero más a esto:

Código (cpp) [Seleccionar] Expandir

#include <iostream>

using namespace std;

int x = 0;

void cambiar(int&);

int main(){
cout<<"Antes: "<<x<<endl;
cambiar(x);
cout<<"Depues: "<<x<<endl;

cin.get();
return 0;
}

void cambiar(int &x){
x=10;
}

y lo mismo he visto en estructuras, por ejemplo un vector de estructura y usarlo sin  declararlo en el paréntesis tipo:

Código (cpp) [Seleccionar] Expandir

void mostrar(){
cout<<prueba[3].dato; //En una función anterior he metido valores dentro de dato
}

Pd2: le tuve que añadir

Código (cpp) [Seleccionar] Expandir

cin.ignore(1,'\n'); por que si ponia "yy" se ponía en modo bucle infinito no se por qué.

Hace nada he visto los puntero a estructura y ahora estoy viendo lo de las pilas, el concepto de pila ya lo tengo claro, pero lo que no entiendo es para que existe el concepto de pila si al hacer un vector de la estructura te ahorras un montón de pasos y sintaxis liosa a la hora de crear una pila. Sobretodo por el hecho de que el vector no depende del "plato" que este arriba si no que se puede llamar a cualquier "plato" y sin destruir la "pila de platos".

Código (cpp) [Seleccionar] Expandir

struct Nodo{
int dato;
}nodo[100], *pila = nodo //&nodo[0]
//Ahora puedo usar cualquier dato de la plia sin estar restringido al nodo superior

Esto hace lo mismo que una pila de 100 nodos pero sin depender de la primera posición y me ahorro todo el procedimiento de ir creando nodos, guardar el dato en int dato, luego vincular el puntero *siguiente al Nodo *pila "El ultimo nodo antes de el", y luego igualar pila al nuevo nodo creado.

Digamos que el concepto de pila y su procedimiento si lo tengo claro, lo que no tengo claro es su utilidad teniendo algo que ya había visto antes como son los vectores de estructura. (De momento solo he visto de C++ todo lo básico hasta punteros y pilas)

Estoy comenzando a ver las pilas y me pareció que parecía igual que un vector de una estructura pero con más parafernalia y mas lioso, en que se diferencia:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <cstdlib>

using namespace std;

struct Nodo{
int dato;
Nodo *siguiente;
}

void agregarPila(Nodo *&,int);
int main(){
Nodo *pila = NULL;




cin.get();
return 0;
}

void agregarPila(Nodo *&pila,int n){
Nodo *nuevo_nodo = new Nodo();
nuevo_nodo.dato = n;
nuevo_nodo.siguiente = pila;
pila = nuevo_nodo;
}

de:

Código (cpp) [Seleccionar] Expandir

#include <iostream>

using namespace std;

struct Nodo{
int dato;
}nodo[2], *pila = nodo //&nodo[0]
//Ahora puedo usar cualquier dato de la plia sin estar restringido al nodo superior

int main(){

cin.get();
return 0;
}

Me parece mejor incluso usar un vector de estructura ya que no estas restringido a ir de forma ascendente. (La única pega que le veo es que tienes que darle un tamaño inicial al vector y si usas de menos estas desperdiciando memoria o si usas de más te quedas corto y no puedes almacenarlo todo)

Hay algunas nomenclaturas que no entiendo como size_t, es de la libreria iostream?, yo de normal le pondría:

Código (cpp) [Seleccionar] Expandir

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

O lo de ayer tambien con el sizeof, lo unico que se me ocurre es que sean clases por lo poco que he visto java, puede ser?.

PD: Estoy viendo las pilas y ya tengo la primera duda xD. No creo que sea un post tan largo como este pero estaría bien si le echas un vistazo  .

Esto es la biblia de los punteros ya xD, lo tengo guardado en la barra de herramientas para tenerlo a la vista entro al chrome y ya le doy a abrir jajaja.

PD: por lo que he visto en el curso no se da más sobre punteros, ya pasa a pilas, a ver que tal jajaja. Acabo de hacer un programa donde podría usar un puntero de una función no?:

Código (cpp) [Seleccionar] Expandir

#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;
}
}

Podría usar un puntero de la funcion multi al usarla en multiplicarMatrices, aun que como tu dices, a mi me parece lo mismo xD.

Bueno saberlo   . Creo que ya he visto todo de los punteros creo. No se si hay punteros de funciones (juraría haber visto algo como: void *funcion() en alguna parte, pero no le encuentro sentido ponerle un puntero a una función a no ser que sea un puntero a un valor que devuelva. Supongo que cuando llegue a la parte de POO haré otro post lleno de preguntas xD, a ver si el profe del curso de udemy se pone las pilas y explica un poco como tu y seguro que no vuelvo a poner ningún post más   .

PD: que sería un mensaje sin PD   , lo bueno del post es que si cuando empiece la uni se me olvida alguna cosita de los puntero me releo el post y ya estaría     .

Gracias por el consejo, cuando hago algo me gusta saber por qué lo hago y como funciona ese algo para poder entenderlo, ya que si no lo entiendo simplemente estaría copiando y pegando y seria perder el tiempo.

PD: Si lo he entendido bien esto:

Código (cpp) [Seleccionar] Expandir

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

La diferencia radicaría en que en la primera se usa para crear una matriz dinámica y así ahorrar espacio en la memoria y en la segunda ya tienes el espacio reservado, no?

PD2: las variables dinámicas no tienes nombre? o solo se les puede llamar a través del puntero del que se crean?

Ahora sí jajaja, ayer estuve apunto de probar el método de pasar el puntero por referencia, pero como no sabía exactamente lo que hacía deseche esa opción  .

Al final a quedado algo tal que así:

Código (cpp) [Seleccionar] Expandir

#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";
}
}

Esto de los punteros me parece todo un mundo la verdad, para cada cosa me cambian la nomenclatura, yo no se como puedes acordarte de todo esto si no lo usas diariamente jajaja.

PD: No se suponía que un puntero es un referencia al espacio de memoria? y que usando "cin>>puntero" te permite guardar el valor en ese espacio, por qué ahora al usar new hace falta pasarlo como puntero referencia y no lo englobaron en 1 sola categoría???, estas cosas son las que me matan   .

PD2: Donde aprendiste a programar por cierto?, al final te voy a tener que contratar como profesor particular xDDD.

PD3: Acabo de hacer un problema para ver si lo interiorizado todo correctamente y ahora parece que sí, a la primera sin fallos (sin contar erratas que de esas siempre hay xD)

Código (cpp) [Seleccionar] Expandir

#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;
}
}

Espero que esto de los punteros no se complique más o al final acabare loco  

Gracias!, es un poco lió que para cada cosa cambien la nomenclatura. Esto de los punteros en serio es un invento del diablo jajaja. Estaba siguiendo hace nada con el curso y ahora estaba viendo punteros con matrices, el otro programador usaba punteros y variables globales y yo lo intente en un principio con valores desde el main() y pasarlos a la función y me da problemas, luego intente hacerlo por variables globales y también se traba o al escribir la matriz o a la hora de mostrarla, te paso el codigo.

Código (cpp) [Seleccionar] Expandir

#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";
}*/
}

Lo que esta en /* es que me falla y para no borrarlo he intentarlo por variables globales e intentar imprimir un solo dato de la matriz lo deje así.

PD: ahora estoy intentando usar variables de columna y fila dentro de la función pero ni eso, se traba al intentar grabar la matriz.

Código (cpp) [Seleccionar] Expandir

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);
}
}

SALIDA: Digite numero de Filas: 3
Digite numero de Columnas: 2
32

Digite elementos matriz:
Digite un numero 0 0:
--------------------------------
Process exited after 3.64 seconds with return value 3221225477
Presione una tecla para continuar . . .

He hecho un pequeño programa con las tres formas de pasar vectores por funciones que me has comentando para interiorizarlo un poco y que no se me olviden xD, pero tengo un problema a la hora de imprimir la dirección de memoría en donde queda almacenada la cadena.

Código (cpp) [Seleccionar] Expandir

#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;

}

Si uso con char me muestra toda la cadena:

Código (cpp) [Seleccionar] Expandir

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

//Salida: Dir.1: b | abc

Pero si lo uso con int me muestra la posición, por?

Código (cpp) [Seleccionar] Expandir

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

PD: pongo daigual para así acordarme que no hace falta poner el mismo nombre de la variable de main en la función, normalmente suelo acortar el nombre o alargarlo pero como era un ejemplo lo he dejado asi.