#include <stdio.h>
typedef struct _vector {
int x;
int y;
} vector_type;
//void printPoint(struct _vector point);
void printPoint(vector_type point);
int main()
{
////////////////////////////////////////
// Declaring a struct without typedef //
////////////////////////////////////////
/// Method 1 ///
/* The form of the stuct is defined and given the identifier _vectorA */
/* The vectorA variable is then declared to be a struct of form _vectorA */
/* (The underscore has no special meaning here.) */
struct _vectorA {
int x;
int y;
};
struct _vectorA vectorA;
/* Members x and y are accessed using the '.' operator */
vectorA.x = 10;
vectorA.y = 20;
printf("vectorA: (%d,%d)\n",vectorA.x,vectorA.y);
/// Method 2 ///
/* The form of the struct is included in the declaration statement */
/* for vectorB. The form identifier can be reused later to declare */
/* additional structs with the same form, such as vectorB2 */
struct _vectorB {
int x;
int y;
} vectorB;
struct _vectorB vectorB2;
vectorB.x = 30;
vectorB.y = 33;
vectorB2.x = 36;
vectorB2.y = 37;
printf("vectorB: (%d,%d)\n",vectorB.x,vectorB.y);
printf("vectorB2: (%d,%d)\n",vectorB2.x,vectorB2.y);
/// Method 3 - variation ///
/* If the struct form is combined with the declaration, the form */
/* identifier is optional. Of course without it, no additional stucts */
/* of the same form can be declared later on. */
struct {
int x;
int y;
} vectorC;
vectorC.x = 40;
vectorC.y = 44;
printf("vectorC: (%d,%d)\n",vectorC.x,vectorC.y);
///Method 4///
/* In addition to declaring a variable as a struct, a variable may be */
/* declared as a pointer to a struct. Multiple struct variables and */
/* pointers to structs may be declared at the same time */
/* (Once again, the struct identifier _vectorD is optional) */
struct _vectorD {
int x;
int y;
} vectorD, *vectorD_ptr=NULL;
vectorD_ptr = &vectorD;
vectorD.x = 50;
vectorD.y = 55;
printf("vectorD: (%d,%d)\n",vectorD.x,vectorD.y);
/* When accessing a struct member via a pointer, one must use '->' */
vectorD_ptr->x = 56;
vectorD_ptr->y = 59;
printf("vectorD: (%d,%d) ",vectorD_ptr->x,vectorD_ptr->y);
printf("//Set and accessed via pointer\n");
//////////////////////////////////////
// Declaring a struct using typedef //
//////////////////////////////////////
/* A new variable type may be defined using typedef, which can then be */
/* used to declare variables and pointers to variables, etc... just like */
/* any other data type. */
typedef struct _vectorE { //Or just: typedef struct {
int x;
int y;
} vectorE_type;
/* Decare vectorE and vectorE_ptr which will hold the address of vectorE */
vectorE_type vectorE, *vectorE_ptr=NULL;
vectorE_ptr = &vectorE;
vectorE.x = 60;
vectorE.y = 66;
printf("vectorE: (%d,%d)\n",vectorE.x,vectorE.y);
vectorE_ptr->x = 63;
vectorE_ptr->y = 65;
printf("vectorE: (%d,%d) ",vectorE_ptr->x,vectorE_ptr->y);
printf("//Set and accessed via pointer\n");
////////////////////////////////////////////////////////
// Initalizing a struct using designated initializers //
////////////////////////////////////////////////////////
typedef struct {
int x;
int y;
} vectorF_type;
/* Initializing a struct without specifying the value/field assocation has */
/* various downsides. One must refer back to the definition to know the
/* field order and the order might change, resulting in broken code. */
vectorF_type vectorF1 = {70,77}; //Without designating the fields
printf("vectorF1: (%d,%d)\n",vectorF1.x,vectorF1.y);
/* Using designated initializers fixes these issues */
vectorF_type vectorF2 = {.x=80, .y=88};
printf("vectorF2: (%d,%d)\n",vectorF2.x,vectorF2.y);
////////////////////////////////////////////////////////
// Initalizing a struct using a compound literal //
////////////////////////////////////////////////////////
/* If you want to declare and initalize a struct seperatly, or if you */
/* want to assign new values using the initialization syntax then you */
/* must use a compound literal, which behaves pretty much like a cast. */
/* The "cast" tells the compiler how to handle the values in the braces. */
vectorF_type vectorF3;
vectorF3 = (vectorF_type){90,99}; //Would fail without "cast"
printf("vectorF3: (%d,%d)\n",vectorF3.x,vectorF3.y);
//Can also combine with designated initializers
vectorF3 = (vectorF_type){.y=92,.x=91}; //Can designate the values in any order
printf("vectorF3: (%d,%d)\n",vectorF3.x,vectorF3.y);
//Can be used to pass anonymous structures to functions
//printPoint({.x=100,.y=101}); <-- Will fail to compile
printPoint((vector_type){.x=100,.y=101});
return 0;
}
void printPoint(vector_type point) {
printf("vector: (%d,%d)\n",point.x,point.y);
}
