[SOLUCIONADO] Prototipo de estructura en C¿Se Puede?

[vangodp]

Hola compañeros.
Tengo la pregunta estupida de la semana jaja
¿¿¿Se puede hacer eso???

Código C:

#include <stdio.h>
#include <stdlib.h>
struct A;
 
int main (){
    A a;
    
    getchar();
    return 0;
}
 
struct A{/*[...]*/};
 

Ya se que
Pero si fuera posible

XDDD


PD Si existe formas de emular acepto sujestiones XDDD

[kspr]

Que tal asi?

Código C:

#include <stdio.h>
 
typedef struct
{
  int a;
  char * fdw;
} Testing;
 
Testing test();
 
int main()
{
 
    printf("%d y %s\n", test().a, test().fdw);
 
    return 0;
}
 
Testing test()
{
  Testing test;
 
  test.a = 1;
  test.fdw = "foros del web";
 
  return test;
}
 

no se me ocurre otra forma :P

EDIT: no habia entendido lo que querias, no se si sea posible, pero si hay alguna forma de emular seria interesante

[vangodp]

No esta mal..Pero el objetivo que intento lograr es librarme de de la implementacion antes de main y dejar una especie de prototipo al igual que se hace con las funciones. =D
Es mejor una linea sola que la estructura completa. Ya intente de todo y se que no es posible, pero por preguntar no se muere nadie. XDD
Lo unico que se me ocurre es poner la estructura en un archivo .h y ya esta. Pero ya tengo 2 archivos. =(

Gracias por comentar.

[eferion]

Nada te impide declarar la estructura en otro fichero y poner un include

[amchacon]

Eso se puede hacer con punteros:

Código C++:

#include <stdio.h>
#include <stdlib.h>
struct A;
 
int main (){
    struct A* a;
 
    getchar();
    return 0;
}
 
struct A{int b;int c;};
 

Pero no puedes inicializar el puntero ahí.

Aquí tienes un uso "práctico" de esta técnica:

Código C:

[HIGHLIGHT="C"]#include <stdio.h>
#include <stdlib.h>
struct A;
 
char quienEsMayor(struct A*,struct A*);
 
struct A* queDevolver(struct A* primero,struct A* segundo)
{
    if (quienEsMayor(primero,segundo)) return primero;
    else return segundo;
}
 
int main (){
 
    getchar();
    return 0;
}
 
struct A{int b;int c;};
 
char quienEsMayor(struct A* a1,struct A* a2)
{
    return a1->b > a2 -> b;
}
 

[/HIGHLIGHT]

Otra versión en C++:

Código C++:

#include <stdio.h>
#include <stdlib.h>
struct A;
 
struct B
{
    A* atributo;
    float otroatributo;
 
    A* getAtributo(){return atributo;};
 
    B(A* cosa)
    {
        atributo = cosa;
        otroatributo = 0.0;
    }
};
int main (){
 
    getchar();
    return 0;
}
 
struct A{int b;int c;};
 

Puedes trabajar pero con algunas limitaciones, como no adceder al contenido del objeto.

Yo esto lo uso para resolver conflictos (una clase A contiene una referencia a una B y una clase B contiene una referencia a una A). Hago esto en el header para evitar el conflicto y luego en el cpp incluyo la clase de forma normal.

[vangodp]

Nada te impide declarar la estructura en otro fichero y poner un include

Cierto! Si lo hiciera en un proyecto seguramente seria lo ideal, pero es por queitar cosas delante de main cuando no uso proyectos, que para mi es el 99% del tiempo. Pero crear un nuevo archivo creo que me duele mas. XDDD

Código C:

#include <stdio.h>
    #include <stdlib.h>
    struct A;
     
    int main (){
        struct A* a;
     
        getchar();
        return 0;
    }
     
    struct A{int b;int c;};
 

*_*

Voy a probar esto

Suerte compañeros, gracias por los comentarios.

[amchacon]

Iniciado por vangodp

*_*

Voy a probar esto

Tiene sus limitaciones, solo te sirve para hacer declaraciones o usos "abstractos". No puedes ni hacer malloc, ni adceder a sus atributos internos... Lo unico que puedes hacer es definir y copiar el puntero de un lado a otro. La única utilidad que le veo es para resolver conflictos.

Voy a sacar un proyecto donde uso está tecnica para resolver un conflicto:

Figura.hpp

Código C++:

#include "Tablero.hpp"
 
class Figura
{
    public:
        Figura(Tablero &m,bool color) : mat(m),Color(color){}
        bool getColor() const {return Color;}
        virtual int mover(Cord,Cord) = 0;
        virtual int tipo() const = 0;
         
        /*...*/
 
    protected:
        Tablero &mat;
        bool Color;
};
 

Tablero.hpp

Código C++:

#include "Cord.hpp"
 
class Figura;
 
class Tablero
{
    public:
        static const bool BLANCO = 0;
        static const bool NEGRO = 1;
 
        Tablero();
        Figura* getPosition(Cord posicion) const;
        bool jaque(bool color);
        /* ... */
    private:
        Figura* Matriz[8][8];
        /*...*/
};
 

Fijate bien, Figura tiene una referencia al tablero actual. Y tablero contiene una matriz de figuras, ambos se referencian mutuamente.

Es absurdo hacer:

Tablero.hpp

Código C++:

#include "Figura.hpp"
 

Figura.hpp

Código C++:

#include "Tablero.hpp"
 

Tablero incluye a figura, y luego desde ahí vuelvo a incluir a figura... Si no le pongo protección contra la inclusión multiple fallará, y si se la pongo, una no encontrará a la otra.

Asi que opté una táctica distinta, figura.hpp incluye a tablero.hpp. Pero tablero.hpp no la incluye, sino que usa el prototipo. Luego en la implementación (.cpp) si incluyo a figura completamente:

Tablero.cpp

Código C++:

#include "Tablero.hpp"
#include "Figura.hpp"
 
//...