Foro de elhacker.net

Hola a todos.
Estoy estudiando estructuras y voy a programar una agenda, al programa le falta todo pero no quiero seguir sin aprender las dos cosas por las que doy de alta este post.-
La primera como puedo insertar typedef y la otra, como hago para declarar la estructura para que se le pueda ingresar de o a 10 contactos (unaAgenda [10]).-
Espero se entienda, estimo que si.-

#include <stdio.h>
 
struct agenda{
	int orden, celular;
	char nombre[30], apellido[30], calle[30], ciudad[30], correo[50];
};
 
int main(void){
	struct agenda unaAgenda;
	struct agenda *ptrAgenda;
	ptrAgenda = &unaAgenda;
 
	(*ptrAgenda).orden = 1;
 
	printf("\n\n %d", (*ptrAgenda).orden);
 
	getchar();
	return 0;
}

Saludos.
Daniel

Tal vez tu estructura "agenda" debiera ser más bien "contacto", y luego hacer una array de contactos.

Hola ivancea96.
Gracias por ocuparte y por el consejo, voy a dejar por el momento lo de typedef, con respecto a la otra duda pude avanzar un poco, solo que me da el siguiente error (expongo a continuación) que por más que modifico el programa no logro solucionar.-

#include <stdio.h>
 
struct agenda{
	int orden, celular;
	char nombre[30], apellido[30], calle[30], ciudad[30], correo[50];
}contacto[10];
 
int main(void){
	struct agenda *ptrContacto;
	ptrContacto = &contacto[0];
 
	(*ptrContacto+3).orden = 3;
 
	//printf("\n\n %d", (*ptrContacto).orden);
 
	getchar();
	return 0;
}

C:\ProgramasNotepad\Pruebas.c: In function 'main':
C:\ProgramasNotepad\Pruebas.c:12:15: error: invalid operands to binary + (have 'struct agenda' and 'int')
  (*ptrContacto+3).orden = 3;

Espero puedas ayudarme.-

Saludos.
Daniel

Es necesario cambiar

(*ptrcontact+3).order = 3;

a

ptrcontact[3].order = 3;

O poniendo los paretesís necesarios al usar arítmetica de punteros

(*(ptrcontact+3)).order = 3;

También usando el operador ->

(ptrcontact + 3)->order = 3;

De lo contrario, de acuerdo con la regla de prioridad  * tiene mayor precedencia sobre + provocando el error en tu caso.

Un Saludo

Hola Blaster.
Muchas gracias, funciona a la perfección, el tema estaba en utilizar correctamente la aritmética de punteros.-

Saludos.
Daniel

Hola gente.
Una vez más acudo a Uds. Para ver si me dan una mano con este nuevo inconveniente.-
La línea que figura como comentario me da error, estuve consultando en internet y no logro dar con la solución-

#include <stdio.h>
 
typedef struct{
	int orden, celular;
	char nombre[30], apellido[30], calle[30], ciudad[30], correo[50];
}agenda[10];
 
void ingreso(agenda *ptrContactos);
 
int main(void){
	agenda contactos;
	ingreso(&contactos);
 
 
	getchar();
	return 0;
}
 
void ingreso(agenda *ptrContactos){
	(*ptrContactos + 3)->orden = 5;
    //(*(ptrContactos)).orden = 5;
 
	printf("\n\n %d", (*ptrContactos + 3)->orden);
}

Saludos.
Daniel

ptrContactos es un puntero de tipo "agenda" que a su vez es un arreglo de diez elementos... luego ptrContactos es un puntero doble. Entonces:

ptrContactos: puntero doble
*ptrContacots: puntero (necesitas el operador '->' en vez del operador '.' )
**ptrContactos: acceso directo a la estructura (necesitas el operador '.' )

Un saludo

No sería mas lógico tener algo como esto?

 
typedef struct contacto{
	int orden, celular;
	char nombre[30], apellido[30], calle[30], ciudad[30], correo[50];
};
 
 
int main(int argc, char *argv[]) {
 
    contacto* miagenda;
    miagenda = (contacto*) malloc(10 * sizeof(contacto));
    miagenda[0].orden = 0;
    strcpy(miagenda[0].nombre, "Nombre");
    strcpy(miagenda[0].apellido, "Apellido");
 

Y no hace falta  el "->" porque [] haria la indireccion.
Se podria hacer

//miagenda[0].apellido;
(miagenda +0)->apellido;
 

Pero vale la pena  complicar la sintaxis?


Saludos

Desde mi punto de vista no merece la pena.

El código tiene que ser lo más sencillo y legible posible para reducir los costes de mantenimiento, el número de errores, y el coste de ampliar el programa... pero la decisión final no depende de nosotros :)

Hola a todos.
Eferion,  me parece muy interesante lo de puntero doble, etc. Yo creí que sabía bastante sobre punteros pero veo que tengo que repasarlos, si estaríamos sentados los dos frente a la misma compu te efectuaría una pregunta, pero no es este el caso, seguramente consultando en la web voy a obtener la respuesta a mi duda.-
_Enko, 2 aclaraciones en cuanto a tu código, la primera es que todavía no llegue a estudiar memoria dinámica y la restante es que el programa se va a extender bastante porque al pedir el ingreso de los datos voy a validar que sean correctos, por lo tanto tengo que utilizar funciones, no debo hacerlo todo dentro de la función principal (main).-
En cuanto a:

Les aclaro mi punto de vista y el criterio del porqué, yo no puedo estar seguro de hacer sólo programas para terceros, que pasa si me trajeran para corregir o modificar programas hechos por otros, en estos casos puedo encontrarme con una gran diversidad de formas de programar y según me dicta mi sentido común debo tener el mayor conocimiento posible, este es el único motivo por el cual este programa(o todos) los hago un tanto complicado.-

Para finalizar, espero alguna respuesta en cuanto a mi planteo para saber cuál es el criterio utilizados por Uds. Al estudiar.

Saludos.
Daniel

Pues sigo  pensando que diseñar todo pasando por parametro un puntero a un arreglo de 10 estructuras no es necesario. Al menos que vayas a tener mas de un arreglo de esos?
Pero el arreglo es uno solo. Entonces para que pasarlo como parametro?

Y si aun pasas ese arreglo como parametro por referencia, pues no pasas el indice del arreglo, entonces que se modifica? Primer elemento, segundo? todos?

typedef struct contacto{
	int orden, celular;
	char nombre[30], apellido[30], calle[30], ciudad[30], correo[50];
};
 
 
void ingresar_datos_(contacto* cntcto)
{
    cntcto->orden = 5;
}
 
int main(int argc, char *argv[]) {
 
    contacto miagenda[10];
    ingresar_datos_(&miagenda[3]);
    miagenda[3].orden == 5;
 

Saludos.

Siempre puedes probar suerte, lo mismo alguno de nosotros es capaz de resolverte la duda.

Por otro lado, me parece estupenda la iniciativa de buscar la solución por tu cuenta. Valerse por uno mismo es ley de vida en este mundo, sobretodo porque cuando alcanzas cierto nivel te das cuenta de que hay muy poquitos recursos a tu alcance que merezcan realmente la pena... y si te atascas al final dependes únicamente de ti mismo para salir del agujero.

Hola a todos.
Espero que no me odien por tanta molestias, pero prefiero que me envíen algún mal pensamiento antes que quedarme con alguna duda.-
Este programa es para que me digan con teoría que le estoy pasando a la función.-

#include <stdio.h>
 
typedef struct{
	int orden, celular;
	char nombre[30], apellido[30], calle[30], ciudad[30], correo[50];
}agenda[10];
 
void ingreso(agenda *ptrContactos);
 
int main(void){
	agenda contactos;
	ingreso(&contactos);
 
 
	getchar();
	return 0;
}
 
void ingreso(agenda *ptrContactos){
	int bucle = 0, cont = 1;
 
	do{
		(*(*ptrContactos + cont)).orden = cont;
		printf("\n\n orden.....................: = %d", (*(*ptrContactos + cont)).orden);		
 
		cont++;
	}while(bucle >= 0 && cont <= 10);
}

Este es para que vean que no pretendo que me den todo hecho, me desconecté de internet, cerré la ventana con el manual y lo logré sin ayuda, no es gran cosa pero me da cierta seguridad.-

#include <stdio.h>
 
typedef struct{
	int dia, mes, año;
}_fecha;
 
void funcPuntero(_fecha *ptr);
 
int main(void){
	_fecha fecha, *ptrFecha;
 
	fecha.dia = 10;
	fecha.mes = 2;
	fecha.año = 2015;
 
	printf("\n hoy es......: %d/%d/%d", fecha.dia, fecha.mes, fecha.año);
 
	ptrFecha = &fecha;
 
	ptrFecha->dia = 11;
	ptrFecha->mes = 3;
	ptrFecha->año = 2016;
 
	printf("\n otra fecha..: %d/%d/%d", ptrFecha->dia, ptrFecha->mes, ptrFecha->año);
 
	funcPuntero(&fecha);
	printf("\n hoy es......: %d/%d/%d", ptrFecha->dia, ptrFecha->mes, ptrFecha->año);
 
	getchar();
	return 0;
}
 
void funcPuntero(_fecha *ptr){
	ptr->dia = 10;
	ptr->mes = 2;
	ptr->año = 2015;
}

Bueno, en definitiva todo tiene que ver con el primer programa es decir modificar los 7 campos del  registro en la función ingreso pasándole un puntero a la estructura agenda pero no copiando todo el array a la función sino tan sólo un puntero al primer elemento.-
Gente mil disculpas si ya me dieron la solución a esto pero estoy tan embotado que tal vez no me dí cuenta.-

Saludos.
Daniel

Demasiado complicado para lo que intentas.

Basta con declarar la funcion con dos parámetros: el primero es la dirección en memoria del array y el segundo su numero de elementos. De esta forma:

#include <stdio.h>
 
struct registro {
   int ordenint;
   int celular;
   char nombre[30];
   char apellido[30];
   char calle[30];
   char ciudad[30];
   char correo[50];
};
 
void ingreso(struct registro *reg, size_t num_regs);
 
int main(void)
{
   struct registro reg[10];
   ingreso(reg, sizeof reg / sizeof reg[0]);
 
   return 0;
}
 
void ingreso(struct registro *reg, size_t num_regs)
{
   size_t i;
 
   for (i = 0; i < num_regs; i++){
      /* Aqui procesas el elemento reg[i] */
   }
}

Un saludo

Hola rir3760.
Me queda una duda, el array reg cuando está dentro de la función ingreso ¿no es un puntero al primer elemento del arreglo? y si es así ¿porque no puedo utilizar el operador flecha (->)? y si me acepta el operador punto (.).-

#include <stdio.h>
 
typedef struct{
	int orden;
	int celular;
	char nombre[30];
	char apellido[30];
	char calle[30];
	char ciudad[30];
	char correo[50];
}registro;
 
void ingreso(registro *reg, size_t num_regs);
 
int main(void){
	registro reg[10];
	ingreso(reg, sizeof reg / sizeof reg[0]);
 
	getchar();
	return 0;
}
 
void ingreso(registro *reg, size_t num_regs){
	size_t i;
 
	for (i = 0; i < num_regs; i++){
        reg[i].orden = i;
		printf("\n orden = %d", reg[i].orden);
	}
}
 

Saludos.
Daniel

Correcto.

Primero, no hay relación entre los operadores ya que "->" aplica a un puntero mientras que "." aplica a un objeto.

Segundo, en tu caso:

void ingreso(registro *reg, size_t num_regs)
{
   /* ... */
 
   reg[i].orden = i;

Tienes el puntero reg y para acceder al objeto apuntado debes aplicar indireccion con "[]" y solo entonces se accede al campo indicado con ".".

Puedes utilizar el operador "->" sin ningún problema:

void ingreso(registro *reg, size_t num_regs)
{
   /* ... */
 
   (reg + i)->orden = i;

Pero me temo estoy repitiendo la explicación (en la primera pagina de este tema) de Blaster, por favor relee el tema con atención.

Un saludo

Hola rir3760.

(http://i62.tinypic.com/13ymsm8.png)
 :) :) :)
Tienes toda la razón, en definitiva se hizo un poco largo, pero realmente he aprendido mucho pero mucho con esto.- ;-) ;-) ;-)
Muchas gracias a todos por el tiempo [Solucionado].- 

Saludos.
Daniel

Hola yo tengo una duda tengo este pedazo de codigo:

# include <iostream>
# include <stdio.h>
# include <stdlib.h>
# include <cstring>
 
# include <Mascota.h>
# include <Cacatuas.h>
 
using std::string;
using namespace std;
 
int  totalMascotas=0;
 
int main()
{
    int numMas, a,resp;
 
    Mascota *cacatuas=new Cacatuas;
 
    cout <<"¿Cuantas mascotas tiene?"<<endl;
    cin>>numMas;
 
    for (a=0;a<numMas;a++){
        cacatuas->pedirDatos();}
 
    for (a=0;a<numMas;a++){
        cout <<"Los datos de  la cacatua son:";
       cout<<((Cacatuas *)cacatua)->getespecieCacatua()<<endl;
    }
    return 0;
}
 
 

Mi problemas esta que cuando mando a imprimir mi apuntador solo me imprime los ultimos valores que introduje en la ultima vuelta del ciclo y queria saber como puedo o si hay alguna forma de que mi apuntador pueda almacenar varios valores
Porfa ayuda!!!! es urgente


[MOD] No está permitido publicar un post por duplicado, el otro te ha sido borrado.

Usa las etiquetas GeShi para publicar codigo.

Mejor sería abrir un tema nuevo para tu problema.