Foro de elhacker.net

Este programa no esta terminado solo quiero que me aclaren si al acceder a cada struct en este caso seccion1, seccion2, seccion3, debo declarar un puntero por cada struct o puedo utilizar un puntero general supongamos *pt?

struct { struct seccion1;
         struct seccion2;
         struct seccion3;
         } secciones, *p1=&secciones,*p2=secciones,*p3=secciones;
         
struct { char asignatura1;
         char asignatura2;
         char asignatura3;
         char asignatura4;
         char asignatura5;
         } seccion1,seccion2,seccion3,

main(){
       
       struct *p1,*p2,*p3,*cat;
       int opc,n;
       
       p1=(secciones*)malloc(sizeof(secciones));
       p2=(secciones*)malloc(sizeof(secciones));
       p3=(secciones*)malloc(sizeof(secciones));
     
int menu(){
       cout<<"\n MENU \n";
       cout<<"1..Ingreso sección 1 (5 materias)\n";
       cout<<"2..Ingreso sección 2 (4 materias)\n";
       cout<<"3..Ingreso sección 3 (2 materias)\n";
       cout<<"4..Volver al menu \n";
       cout<<"5..salir\n";
       cin>>opc;
       return(opc);
       }
       
       switch (menu()):
       case 1:
       ingreso(p1->secciones.seccion1,&n=5);
       break;
       case 2:
       ingreso(p2->secciones.seccion2,&n=4);
       break;
       case 3:
       ingreso(p3->secciones.seccion3,&n=2);
       break;
       case 4:
       menu();
       break;
       default:
       break;
       }
       
void ingreso(struct p1->secciones.seccion1,int *cat){

if(*cat>0){
cout<<"\n Ingrese asignatura 1: "; cin>>p1->secciones.seccion1.asignatura1;
cout<<"\n Ingrese asignatura 2: "; cin>>p1->secciones.seccion1.asignatura2;

if(*cat<=2){
cout<<"\n Ingrese asignatura 3: "; cin>>p1->secciones.seccion2.asignatura3;
cout<<"\n Ingrese asignatura 4: "; cin>>p1->secciones.seccion2.asignatura4;
}
if(*cat<=5){
cout<<"\n Ingrese asignatura 5: "; cin>>p1->secciones.seccion1.asignatura5;
}
}

Hola Mari2012 , no, no tienes porqué declarar un puntero por cada struct , accedes directamente con el operador '.' sin las comillas y un apunte las estructuras seccion1 , sección2 y seccion3 tienes que declararlas antes de la estructura secciones ya que las utiliza.

Otra aclaración , las funciones no se declaran dentro de las llaves del main normalmente, es decir :

#include <iostream>
//Declaramos las funciones
int ejemplo_funcion1 ();
int ejemplo_funcion2 ();
int ejemplo_funcion3 ();
int main()
  {
 
  }//Fin del main.
  //Definimos las funciones
int ejemplo_funcion1 ()
  {
    return 0;
  }
int ejemplo_funcion2 ()
  {
    return 0;
  }
int ejemplo_funcion3 ()
  {
  return 0;
  }
 

PD : No escribas en mayúsculas, dá mala impresión antes de leer el mensaje, por lo menos a mí , y cuando vayas a postear un código , lo seleccionas y te vas donde pone GeSHi , abres el menú desplegable y seleccionas el lenguaje que sea para que se vea coloreado como el de arriba.

¡Un saludo!  ;D

Gracias avesudra, tenia en cuenta que faltaba los prototipos de funciones, el codigo no lo he terminado, tambien para la proxima omitire las mayusculas, la mayoria no lo utiliza, ahora tengo una nueva duda en la linea 20, el compilador indica :
 variable or field `ingreso' declared void

#include<stdio.h>            
#include<stdlib.h>
#include<iostream>
using namespace std;
 
 
struct { char asignatura1;
         char asignatura2;
         char asignatura3;
         char asignatura4;
         char asignatura5;
         } seccion1,seccion2,seccion3;
 
         struct { struct seccion1;
                  struct seccion2;
                  struct seccion3;
                  } secciones, *pt=&secciones;
 
int menu(int opc);
void ingreso(struct *,int *);
 
main(){
 
       struct *pt;
       int opc,n,*cat;
 
 
       pt=(secciones*)malloc(sizeof(secciones));
 
       switch (menu(opc)){
       case 1:
       ingreso(pt->secciones.seccion1,&n=5);
       break;
       case 2:
       ingreso(pt->secciones.seccion2,&n=4);
       break;
       case 3:
       ingreso(pt->secciones.seccion3,&n=2);
       break;
       case 4:
       break;
       default:
       cout<<"\n OPCION INVALIDA";
       break;
       }
 
       system("pause");
       }
 
       int menu(int opc){
       cout<<"\n MENU \n";
       cout<<"1..Ingreso sección 1 (5 materias)\n";
       cout<<"2..Ingreso sección 2 (4 materias)\n";
       cout<<"3..Ingreso sección 3 (2 materias)\n";
       cout<<"4..salir\n";
       cin>>opc;
       return(opc);
       }
 
void ingreso(struct pt->secciones.seccion1,int *cat){
do{
if(*cat>0){
cout<<"\n Ingrese asignatura 1: "; cin>>pt->secciones.seccion1.asignatura1;
cout<<"\n Ingrese asignatura 2: "; cin>>pt->secciones.seccion1.asignatura2;
}
if(*cat>2){
cout<<"\n Ingrese asignatura 3: "; cin>>pt->secciones.seccion2.asignatura3;
cout<<"\n Ingrese asignatura 4: "; cin>>pt->secciones.seccion2.asignatura4;
}
if((*cat>4)&&(*cat<=5)){
cout<<"\n Ingrese asignatura 5: "; cin>>pt->secciones.seccion1.asignatura5;
}
}while(*cat<=5);
}

Mmmm pues es porque no indicas cual es la estructura a pasar es decir , tu para poner un puntero a una estructura tienes que poner cual es la estructura:

void ingreso(struct tipo * , int *);

Aunque en tu código veo innecesario el paso de la estructura pues después siempre asignas el mismo campo, no sé si notas que la estructura secciones es global.
Otra cosa a corregir , en C:

#include <stdio.h>
#include <stdlib.h>

En C++ :

#include <cstdio>
#include <cstdlib>

Tienes un poco de lio con los punteros y las estructuras.Para declarar una estructura puedes hacer esto:

struct base_de_datos 
{
char nombre[100];
char apellidos[100];
int edad;
};
int main()
{
 //y ahora declaras una variable de tipo base_de_datos así:
base_de_datos listacompleta1;
}

Si lo hacemos como tu haces tenemos:

struct
{
char nombre[100];
char apellidos[100];
int edad;
}base_de_datos;//VARIABLE O ESTRUCTURA GLOBAL!!!!
int main()
{
 //ya no puedes declarar una estructura igual a base_de_datos
//pero base_de_datos es una estructura
}

Yo que tú le pegaba un buen repaso a las estructuras , haría algo con ellas un poco complejo y después pasas al manejo de punteros con ellas , si no te puedes volver loco/a.

Si tendre que reforzar la base, ahora estoy probando otra manera de manipular los punteros en este caso, si tengo:

struct{ int linea1;
           int linea2;
           int linea3;
           int linea4;
           int linea5;
          }turno1,turno2,turno3,*pt;

 

pt=&turno1;
 pt=&turno2;
 pt=&turno3;

Es decir:

struct{ int miembro1;
          int miembro2;
          int miembro n;
         }variable1, variable2, variable n,*pt;
 
Es necesario asignarle la direccion de cada variable a pt ?
 
pt=&variable1;
pt=&variable2;
pt=&variable n;

 ;D

Pero es que no tienes nada claro porque date cuenta que ahí en ese pedazo de código , el puntero pt termina apuntando SOLO a variable n , que por cierto un nombre de una variable no puede llevar espacios. Y no hace falta asignarle un puntero a una variable global , que ya es accesible en todo el programa.