What is the advantages of structure in c language?

Answer 1

A C++ structure (struct) is simply a type of class where all members have public access by default (class members are private by default). Aside from that, C++ classes and structures have exactly the same meaning; the following definitions are exactly equivalent:

struct S {

int x; // public by default

private:

int y;

};

class C { public:

int x;

private:

int y;

};

Note that although the physical representations of S and C types are exactly equivalent, they are still fundamentally different types. That is, you cannot pass an object of type C into a function that expects an object of type S, unless you explicitly define a cast operator to perform an implicit conversion from C to S.

By convention you will typically use structures to define PODs ('plain old data' types where all members are implicitly public and the type is not itself derived from another non-POD type) and use classes when you need to establish an invariant. However, there's nothing in the language that fundamentally prevents you from using a structure to establish an invariant or to use a class as a POD. The only real disadvantage in doing so is that (conventional) C++ programmers may question why you would choose to do so; it can only lead to confusion.

Answer 2

The main advantage of a struct is that it allows us to pass and return multiple values as a single data type. We can also use arrays to do this, however an array only allows us to pass and return multiple values of homogeneous types whereas a struct allows us to return heterogeneous type. Moreover, an array does not support the copy semantic so we cannot pass and return arrays by value, but we can with a struct.

Typically we use a struct to associate several pieces of information and treat the whole as a single entity, much as we would a database record except the fields are called data members.

Declaring and using struct data types is somewhat cumbersome because the struct keyword is also part of the type name:

struct point {

int x;

int y;

};

struct point p;

To simplify things, we typically declare an alias for the struct:

typedef struct point {

int x; int y;

} point_t;

point_t p;

The _t suffix usually denotes an alias for a type, however we often simplify further by placing the suffix on the type and leave the alias undecorated:

typedef struct point_t {

int x;

int y;

} point;

point p;

To initialise a struct, we can use member-wise initialisation:

point p {42, 0};

Or we can initialise members individually:

point p;

p.x = 42;

p.y = 0;

Note that we use the member-access operator (.) to access the individual members of a struct.

We can also use the copy semantic to initialise a struct:

point q {p}; // same as: struct q = p;

The copy semantic allows us to pass and return struct data types by value:

point scale (point p, double s) {

p.x *= s;

p.y *= s;

return p;

}

The size of a struct is the sum of its member types plus any padding bytes to allow for memory alignment. When the size of a struct is larger than a pointer, passing by reference is usually preferred:

point* scale (point* p, double s) {

p->x *= s;

p->y *= s;

return p;

}

Note that we use the pointer-to-member operator (->) when dereferencing the members of a pointer to struct.

Any data type may be used to define the members of a struct, including other struct types (known as embedded structures). For instance:

typedef struct circle_t {

point centre; // embedded structure

int radius;

} circle;

circle c {0, 0, 10}; // c.centre.x=0, c.centre.y=0, c.radius=10

A struct may also refer to its own type through a member pointer:

typedef struct node_t {

int data;

node* next; // pointer to the next node in a sequence of nodes (e.g., a list of nodes)

} node;

Answer 3

No Data hiding

Cannot add complex numbers

Answer 4

mala mahiti asat ter bhenchod tuzyakade kashala alo asto

Answer 5

when we want to integrate information in one entity then structure is used