SOLUTION

The syntax of a structure definition takes the following form :
struct tag
{
   type variable-name;
   type variable-name;
   type variable-name;
   ...
   ...
} structure-variables;

SOLUTION

A data structure is a group of data elements grouped together under one name. Once defined,  a structure becomes a user defined data type. New variables, arrays, even structures can be defined in terms of this data type.  It is treated equivalent to the fundamental data types. Data structure are defined  with keyword ‘struct’, i.e., followed by the tag and the structure members within braces, ending with a semicolon.                           

SOLUTION

We need array to store marks of 32 students. If other details of these students were also being stored we could use an array of structures.    

SOLUTION

In call-by-value, any changes made to the contents of the structure inside the function to which it is passed do not affect the structure used as an argument.     

SOLUTION

A # sign in the beginning of a statement means it is a preprocessor directive. i.e. the instructions given here will be processed before the program is compiled.                     

SOLUTION

To store employee's details structure should be used.

SOLUTION

A structure is a group of data elements grouped together under one name. The  keyword ‘struct’ is followed by the tag and the structure members within braces, ending with a semicolon.                           

SOLUTION

When tag is missing, only one variable can be declared. Here, three have been declared and this is wrong.         

SOLUTION

The structure definition is not terminated properly as the semicolon ';' is missing after the closing brace.           

SOLUTION

The structure variable.
Example: in T.hour, hour is a structure member to the right of the dot operator. To the left of the dot operator is T, a structure variable.                

SOLUTION

struct time{ int hour;
                        int min;

                        int sec;

SOLUTION

Related data elements that may be stored as variables of different data types form the components of a structure.

SOLUTION

date D, *DT;           

SOLUTION

The #define preprocessor allows us to define symbolic names and constants. #define allows you to make text substitutions before compiling the program.

SOLUTION

A structure may be local (to a function), if defined within a function. That is, no function other than the one which defines it, can access it (the structure). A structure may be global (to all functions within a program) if defined outside all functions. That is, any function can then access it.

SOLUTION

If declared within main() it becomes local to the function main().  

SOLUTION

The correct statement is : cout << emp.name;
Once a structure variable has been defined, its members can be accessed through the use of the dot operator. The syntax for accessing a structure element is:
structure-name.element-name  

SOLUTION

Since an array can contain similar elements, the combination having structures within an array is an array of structures. To declare an array of structures, you must first define a structure and then declare an array variable of that type.

SOLUTION

Preprocessor commands are called DIRECTIVES and begin with a pound/hash symbol (#). No white space should appear before the # and a semi colon is NOT required at the end.

SOLUTION

The keyword typedef does not actually create a new data class, rather it defines a new name for an existing type. The syntax of the typedef statement is
typedef type name;
where type is any C++ datatype and name is the new name for this type.

SOLUTION

v1 = v2 will work if v1 and v2 are variables of the same type. If they are made of the same type of components but are known as different data types, then it won't.

SOLUTION

typedef salary amount;    
Here, salary is not a data type.

SOLUTION

Arrays are collections of analogous elements.

SOLUTION

The structure variable name followed by a period (.) and the element name references to that individual structure element. The first component of an expression involving the dot operator is the name of the specific structure variable, not the name of the structure specifier.

SOLUTION

A structure can be nested inside another structure. Following code fragment illustrates it :
struct addr
{
    int hno;
    char area[26];
    char city[26];
    char state[26];
};
struct emp
{
    int empno;
    char name[26];
    char desig[16];
    addr address;
    float basic;
};
emp worker;    

SOLUTION

When a structure element happens to be an array, it is treated in the same way as arrays are treated. The only additional thing to be kept in mind is that, to access it, its structure name followed by a dot (.) and the array name is to be given.
The given fragment declared a structure variable learner of structure type stu that contains an element which is an array of 5 floats to store marks of a student in 5 different subjects.  

SOLUTION

When the structure tag is omitted, only one structure variable is needed.
For example,
struct
{
short day;
short month;
short year;
} birth_date;
declares one variable birth_date as defined by the structure preceding it, but no more structure variables can be created with it.

SOLUTION

A structure may be local (to a function), if defined within a function. No function other than the one which defines it, can access it (the structures). A structure may be global (to all functions within a program) if defined outisde all functions. That is, any function can then access it.

SOLUTION

Here, the add is a structure tag and it identifies this particular structure and its type specifier.

SOLUTION

A structure is a collection of variables referenced under one name. The keyword struct tells the compiler that a structure is being defined.
For example,
struct date
{
  short day;
  short month;
  short year;
};
Here, the date is a structure tag and it identifies this particular data structure and its type specifier.

SOLUTION

All members are public by default but can be made protected and private.

SOLUTION

A structure is a collection of variables referenced under one name. The keyword struct tells the compiler that a structure is being defined.

SOLUTION

Structure assignemnt is possible only if both the structures are of same structure type.

SOLUTION

By default all members of a class are private. Private access specifier specify that the member-functions or member-variables cannot get accessed outside the class.

SOLUTION

The naming system of a structure follows the simple rules like the naming system of a variable. As a variable name cannot start with a number so in the same way the name of the structure cannot start with a number.

SOLUTION

Each instance of a structure is known as the structure variable.

SOLUTION

A structure variable can be passed by value as well as by reference.Pass-by-Value makes a copy of the variable and can be quite slow and inefficient if the variable is large like an array. C++ also allows Pass-by-Reference where the address of the variable is passed in. It is useful when original values are to be changed.

SOLUTION

- > is the member access operator to access the pointers being declared, inside a structure.

SOLUTION

A structure is known as a conglomerate data type because it is a group of several variables under one roof.

SOLUTION

To access a variable or member of a structure we use ‘.’ operator. The syntax to access a member of structure is – Structure_name.Member_name

SOLUTION

Data type struct is a logical collection of related dissimilar data elements that can be used as a single unit for Input/Output operation.

SOLUTION

For all arrays in C++, the indexing begins at 0. Therefore, when we want to access the data of the third employee in the list, then the 2nd index structure name will be written.

SOLUTION

A macro with arguments has its arguments substituted for replacement text, when the macro is expanded. A macro substitutes text only; It does not check for data types.

SOLUTION

P1 is an instance of structure person that includes name, which in itself is another structure.
So, complete access can be done by the following statement: P1.p.title, P1.p.fname, P1.p.lname

SOLUTION

When we declare an instance of a structure, then simultaneously it has to be initialized.

SOLUTION

a function may return the members of a structure , Only one value can be returned by a function, either the whole structure or just one member.

SOLUTION

For ABC, a reference variable is being used while for char, it is being passed by value.

SOLUTION

While terminating a structure, a semi colon is used to end this up.

SOLUTION

When a structure is passed by reference the called function declares a reference for the passed structure and refers to the original structure elements through its reference. Thus, the called function works with the original values.

SOLUTION

When a structure is used as an argument to a function, the entire structure is passed using the standard call-by-value method. This means that any changes made to the contents of the structure inside the function to which it is passed do not affect the structure used as an argument.

SOLUTION

Preprocessor commands are called DIRECTIVES and begin with a pound/hash symbol (#). No white space should appear before the # and a semi colon is NOT required at the end.

SOLUTION

In a class, all members are private by default, on the other hand, structure is actually a class (in C++) declared with keyword struct. By default, all members are public in a structure.

SOLUTION

It is correct because it is assigning values of float type time and int type distance.

SOLUTION

It increments the pointer by the size of the structure.

SOLUTION

 typedef declaration lets you define your own identifiers that can be used in place of type specifiers such as int, float, and double.

SOLUTION

The above given structure has four components namely *name, hw[], test[] and avg.

SOLUTION

Members cannot be initialized inside a structure.

SOLUTION

Since, date is a nested structure, so it should be declared before info.

SOLUTION

D1=d2 is wrong,  because both are different data types.
date d4; d4={12,2,2005}; is incorrect because it is assigning values to a declared member.

SOLUTION

a1.x or a2->x, a2 is a pointer variable. Hence, uses -> to access the member.

SOLUTION

When tag is missing, only one variable can be declared. Here, three have been declared, therefore, this is wrong.

SOLUTION

A semicolon should always terminate a structure.

SOLUTION

When we declare an instance of a structure, then simultaneously it has to be initialized.

SOLUTION

P1 is an instance of structure person which includes name which in itself is another structure. So, complete access can be done by the statement :
       P1.p.title, P1.p.fname, P1.p.lname

SOLUTION

The sequence of calling functions is : disp (A); disp (B); disp (C);, and the output is displayed according to this sequence.

SOLUTION

Any array starts from index 0. So, the third employee’s details can be obtained by NE[2].name and NE[2].code.

SOLUTION

Variables are never initialized during a structure declaration.

SOLUTION

r is the member of structure B and x is a member of structure A, which has been nested inside B.

SOLUTION

A value can never be assigned inside a structure.

SOLUTION

The dot operator has a structure variable on the left and structure member on the right side.

SOLUTION

The syntax for structure declaration is :     struct structure_name
  {
     member_type1 member_name1;
     member_type2 member_name2;
     member_type3 member_name3;
    .
    .
  } object_names;

SOLUTION

gets( stu_name); because methods are accessed with dot operator.
int age=17; because, we cannot initialize variables within a structure.

SOLUTION

It should be cout << emp.name.

SOLUTION

It assigns data in a specified format to the data transfer object or the clipboard data object.

SOLUTION

The constructor is a special member function that is automatically called when an object is created. It has a same name as that of a class.

SOLUTION

The data within a class is private, i.e., the data is hidden so that it will be safe from accidental manipulation. The functions are public so that they can be accessed from outside the class.

SOLUTION

When no constructor is present in the class the compiler builds an implicit constructor.

SOLUTION

The constructors can take any one or more arguments, whereas the destructors take no arguments. Both the constructors and destructors are called automatically.

SOLUTION

A destructor has the same name as the constructor (which is same as the class name) but is preceded by a tilde.

SOLUTION

The destructors are used to deallocate memory that was allocated for the object by the constructor.

SOLUTION

A class may be declared within another class. A class declared within another class is called a nested class. The outer class is known as enclosing class and the inner class is known as nested class.

SOLUTION

The class specification takes place in two parts : a) class definition, which describes the component members (both data members and function members) of the class. b) Class method definitions which describe how certain class member functions are implemented.

SOLUTION

An object is said to be a global object if it is declared outside all the function bodies and it means that this object is globally available to all the functions in the program i.e., this object can be used anywhere in the program.

SOLUTION

An object is said to be a local object if it is declared within a function, which means that this object is locally available to the function that declares it and cannot be used outside the function declaring it.

SOLUTION

The wrapping up of data and functions into single unit (class) is known as encapsulation. The programmer cannot directly access data. The data is accessible only through functions present inside class.

SOLUTION

C++ supports array of any data type including class type. Array having class type elements is known as array of objects. Here, the array marks contains 10 objects, namely, marks[0], marks[1], marks[2],..marks[9]. To access data member marks of 3rd object in the array, we will write : result[2].marks.

SOLUTION

An object can be passed in two ways - by value and by reference. When an object is passed by value, the function creates its own copy of the object and works with its own copy. Therefore, any changes made to the object inside the function do not affect the original object. However, when an object is passed by reference, its memory address is passed to the function so that the called function works directly on the original object used in the function call.

SOLUTION

A member function can access both static and ordinary data members whereas static member function can access only static members.

SOLUTION

Member functions have full access privilege to both the public and private members of the class while, in general, nonmember functions have access only to public members of the class.

SOLUTION

The classes in C++ have 3 important access levels. They are Private, Public and Protected. Private: The members are accessible only by the member functions or friend functions. Protected: These members are accessible by the member functions of the class and the classes which are derived from this class. Public: Accessible by any external member.

SOLUTION

Encapsulation is the concept of binding of data and functions.The data members are allowed to access by appropriate class functions or methods.Data members can't access from outside class.

SOLUTION

There are two member function in class B : getDat() and showDat(). Here, the scope of functions is public. Member functions are set of operations that may be applied to objects of that class.

SOLUTION

The private data of a class can be accessed only through the member functions of that class. The public members can be accessed by non-member functions through the objects of that class. The public member functions of a class are called by non-member functions using the objects. The general form for calling a member function is : object-name.function-name(actual arguments);

SOLUTION

Scope resolution operator is used in C++ class, when the member functions are declared outside the class definition.

SOLUTION

The syntax of class declaration is: 

class
{
   
    access specifier :
     data members; member functions;

};

SOLUTION

The inline functions are a C++ enhancement designed to speed up programs. The distinction between normal functions and inline functions is the different compilation process for them.

SOLUTION

A class groups its members into three sections : private, protected and public. The private and protected members remain hidden from outside world. Thus, through private and protected members, a class enforces data hiding.

SOLUTION

A member function can access both ordinary members as well as static members whereas a static member function can access only static members.

SOLUTION

The constructor is a special member function that allows us to set up values while defining the object, without the need to make a separate call to a member function.

SOLUTION

A class is said to be a local class, if its definition occurs within the class body.