Data types such as int, float, char are known as built-in types. Although useful, built-in types do not provide the flexibility required to write complex applications. C++ circumvents this issue by providing a mechanism to create user-defined types. User-defined types provide a better representation of program objects used in complex applications.

User-defined types are made up of built-in types and the mechanism use to create them are:

• Structures
• Classes

In this article, I will talk you about Structures. In Part II of this article, I will talk about Classes.

Structures

A Data Structure provides a mechanism to organize several built-in types into a single entity. A Data Structure consist of the following syntax:

struct User_Defined_Type_Name{

built_in_type;
built_in_type;
built_in_type;

}

The struct keyword declares a structure of type "User_Defined_Type_Name" and defines the built-in types within the structure. Built-in data types within a structure are known as Data Members.

For example, the code snippet below declares a Structure of type Student with several data members.

struct Student{

    //Data members of the structure
    int age; 
    float GPA;
    char grade;
};

Student is an User-Defined Type. When you define a variable of type "Student," an object is created with a memory location and storage.

For example, in the snippet below, line 1 defines a structure, harold, of type Student. The definition allocates enough memory to hold all three built-in data types. In this instance: grade, GPA, and age.

int main(){

    Student harold; //1. Declaring a structure variable

    return 0;
}

Accessing data members

To access a data member in a structure, you must use the dot "." operator. For example, in the snippet below, the data member "age" is accessed using the dot operator (line 2).

int main(){

    Student harold; //1. Declaring a structure variable

    harold.age=29; //Access the structure data member "age"

    return 0;
}

The dot operator is used when a Structure is local to a function, has been declared globally or is "passed by value" to a function.

For example, in line 6, the structure is "passed by value" to the function "printAge." In line 2, the data member is accessed using the dot operator.

void printAge(Student uStudent); //1. Declaring function with "pass by value" argument

void printAge(Student uStudent){

    int age=uStudent.age; //2. Accessing the structure data member with "." operator

    std::cout<<"Print Age: "<<age<<std::endl; //3. Print student age

}

int main(){

    Student harold; //4. Declare a structure variable

    harold.age=29; //5. Set age of student

    printAge(harold); //6. call function and pass the structure by value

    return 0;
}

The "->" is also used to access the structure's data members. However, the "->" operator is used when a structure is "passed by reference" to a function.

For example, in line 5, the structure is "passed by reference" to the function "changeAge." In line 2, the data member is accessed and modified using the "->" operator.

void changeAge(Student *uStudent); //1. Declaring function with "pass by reference" argument

void changeAge(Student *uStudent){

    uStudent->age=30; //2. Accessing the structure data member with "->" operator

}

int main(){

    Student harold; //3. Declare a structure variable

    harold.age=29; //4. Set age of student

    changeAge(&harold); //5. call function and pass the structure by reference

    std::cout<<"Print age:"<<harold.age<<std::endl; //6. Print the new age of student

    return 0;
}

In Part II of this article, I will talk about the second mechanism used to create user-defined types. i.e., Classes.

Hope this helps.