Week 9: Structs

By the end of this week, you will be able to:

Learn how to write to a file
Learn how to create structs
Learn how to access data in structs
Learn how to write functions that use structs
Learn the basics of object oriented programming
Learn about data members, member functions, and constructors.

CONTENTS:

Readings
Background
PreQuiz (due Monday March 10 at 9am)
Recitation
Recitation Submission Guidelines
Homework 7

Readings

Please note the advised readings of “Brief C++ Late Objects” - Cay Horstmann:

Monday: 8.3, 7.7
Wednesday: 7.7
Friday: 7.7, 9.1, 9.2, 9.3

Background

File Output

We discussed reading from a file last week. Here, we will show how we can write to a file. First, you define an ofstream variable and open the file you would like to write to. Then you can write to the output file using the same operation you used with cout, <<, and endl.

    
// Create the output file object
ofstream file_out;
// Opening the output file
file_out.open("output.txt");

// Writing something to the output file
file_out << "writing a sentence to the output file" << endl;

// Writing the value of the variable to the file
string test_string = "you can also write the content of the variable";
file_out << test_string << endl;
file_out.close();

The output.txt will have the following content:

writing a sentence to the output file

you can also write the content of the variable

Structs

In C++, we can define a structure using the keyword struct like so:

struct State
{
    string name;
    int area;
};  // <-- semicolon after struct definition

This defines a new type, State, that you can use for declaring variables, e.g.

//create a State variable with no name or area
State emptyState;

//create a State variable with a name and area
State colorado{"Colorado", 104094};

The variables emptyState and colorado both have two named attributes, called members - name and area. We can access each member using dot notation, e.g.

//set members for empty State
emptyState.name = "Texas";
emptyState.area = 268596;

//get members for colorado
cout << colorado.name << " has an area of " << colorado.area << " square miles." << endl;

Expected output:

Colorado has an area of 104094 square miles.

If we want to compare two structs, we cannot do so directly. Instead, we must compare each data member individually to see if they match, e.g.

//check each data member by one
if(colorado.name == emptyState.name && colorado.area == emptyState.area)
{
    cout << "These are the same state!" << endl;
}
else
{
    cout << "These are not the same state!" << endl;
}

Expected output:

These are not the same state!

Classes

When writing complex programs, sometimes the built-in data types (such as int, char, string) don’t offer developers enough functionality or flexibility to solve their problems. A solution is for the developer (you - yes, you!) to create your own custom data types to use, called classes. Classes are user-defined data types, which hold their own data members and member functions, which can be accessed and used by creating an instance of that class. A class is like a blueprint for an object, customized for whatever particular problem the programmer is working on.

String, for example, is a class in C++ which holds data (the characters comprising the string) and supports useful member functions like substr which operate on this data.

Below is an example of the basic definition of a class in C++.

class ClassName{
    public:
        //The public interface
        //Member functions

    private:
        //The private data members
}; //must end with a semicolon

Anatomy of a Class

Class Name

A class is defined in C++ using the keyword class followed by the name of the class. The body of the class is defined inside the curly brackets and terminated by a semicolon at the end. This class name will be how you reference any variables or objects you create of that type. For example:

ClassName objectName;

The above line would create a new object (variable) with name objectName and of type ClassName, and this object would have all the properties that you have defined within the class ClassName.

Access Specifiers

Access specifiers in a class are used to set the accessibility of the class members. That is, they restrict access by outside functions to the class members.

Consider the following analogy:

Imagine an intelligence agency like the CIA, that has 10 senior members. Such an organization holds various sorts of information, and needs some way of determining who has access to any given piece of information. Some information concerning classified or dangerous operations may only be accessible to the 10 senior members of the agency, and not directly accessible by any other person. This data would be private.

In a class, like in our intelligence agency, these private data members are only accessible by a class’s member functions and not directly accessible by any object or function outside the class.

Some other information may be available to anyone who wants to know about it. This is public data. Even people outside the CIA can know about it, and the agency might release this information through press releases or other means. In terms of our class, this public data can be accessed by any member function of the class, as well as outside functions and objects, even other classes. The public members of a class can be accessed from anywhere in the program using the direct member access operator (.) with the object of that class.

Data Members and Member Functions

Data members are the data variables and member functions are the functions used to manipulate these variables; together, data members and member functions define the properties and behavior of the objects in a Class.

The data members declared in any class definition can be fundamental data types (like int, char, float, etc.), arrays, or even other classes.

For example, for string objects, the data member is a char array[] that holds all of the individual letters of your string. Some of a string’s member functions that we have used already are functions like .substr() and .length().

Accessing Data Members

Keeping with our intelligence agency example, the code below defines a class that holds information for any general agency. In the main function, we then create a new IntelligenceAgency object called CIA, and we set its organizationName to “CIA” by using the access operator (.) and the corresponding data member’s name. However, we cannot access the classifiedIntelligence data member in the same way. Not everyone has access to that private data.

Instead, we need to use a member function of the IntelligenceAgency class, getClassifiedIntelligence(), in order to see that information. This allows us to control the release of private information by our IntelligenceAgency.

Additionally, the main function includes four different ways of creating objects with descriptions in the comments next to it.

class IntelligenceAgency
{
    public:
        IntelligenceAgency();         // Default constructor
        IntelligenceAgency(string classified_intelligence_input); // Parameterized constructor  
        string organizationName;
        string getClassifiedIntelligence();
        void setClassifiedIntelligence(string classifiedIntelligenceInput);

    private:
        string classifiedIntelligence;
};

int main()
{
    IntelligenceAgency CIA;
    CIA.organization_name = "CIA";
    cout << CIA.classifiedIntelligence; // gives an error
    cout << CIA.getClassifiedIntelligence();
    
    // four types of constructor calls
    IntelligenceAgency abc; // creating an IntelligenceAgency object with the default constructor 
    IntelligenceAgency xyz = IntelligenceAgency(); // creating an IntelligenceAgency 
    //object with the default constructor 
    IntelligenceAgency pqr("PQR"); // creating an IntelligenceAgency 
    //object with a paramaterized constructor
    IntelligenceAgency rst = IntelligenceAgency("RST"); // creating an IntelligenceAgency 
    //object with a paramaterized constructor
}

Defining Member Functions

You may have noticed that we declared various member functions in our class definition, but we did not specify how they will work when called. The body of the function still needs to be written. The solution is to define a function, such as getClassifiedIntelligence(), corresponding to our class’s functions. But how does our program know that these functions are the same as the ones we declared in our class? You as the developer need to explicitly tell the computer that these functions you are defining are the same ones you declared earlier.

string IntelligenceAgency::getClassifiedIntelligence()
{
    return classifiedIntelligence;
}
void IntelligenceAgency::setClassifiedIntelligence(string classifiedIntelligenceInput)
{
    classifiedIntelligence = classifiedIntelligenceInput;
}

We start the definition as we do any function, with the return type. Then, we have to add a specifier IntelligenceAgency:: that lets our program know that this function and the one we declared inside the class are the same. We can see that this function returns the class’ classifiedIntelligence to the user.

Functions like getClassifiedIntelligence() are called accessor/getter functions. This is because they retrieve or `get’ the private data members of a class object and return it to the program so that these values may be used elsewhere.

The second function, setClassifiedIntelligence(string classifiedIntelligenceInput), is called a mutator/setter function. These allow functions from other parts of our program to modify or ‘set’ the private data members of our class objects. Getters and setters are the functions that our program uses to interact with the private data members of our class objects.

Structs and Classes

A class can have a struct as a data member, much like how a class could have any other type of data member. It’s important to make sure that the class header file (the .h file) can see the definition of the struct. This can be accomplished by defining the struct inside of the .h file, like below:

// filename: example.h
struct State
{
    string name;
    int area;
};                // don't forget the semicolon

class Example
{
    private:
        State my_state_;
        //other data members

    public:
        //setter accepts a State parameter
        void setState(State new_state);

        //getter returns the State member variable
        State getState();

        //other member methods
};

Any file that includes the .h file shown above will be able to use instances of the State struct, so you will not need to define the State struct anywhere else.

When to use Structs vs Classes

While structs and classes are similar, there are some key differences between them. When deciding whether you should use one over the other, consider the functionality you’d like to achieve. A good rule of thumb is to ask whether the data type you’re defining will need to have any methods or private variables. If it will, then you should create a class. If all members can be public and there are no methods, then a struct may be better.

PreQuiz (due Monday March 10 at 9am)

Please complete your "pre-quiz" for the week on Canvas. This is due Monday morning at 9am. Here is a link to the quiz for Spring 2025: Recitation 9 Pre-quiz

Recitation

Recitation Spot The Error- Problem 1

The Louvre Museum wants to determine its busiest day of the week so it can allocate more staff to assist with guided tours. The museum keeps a log of daily visitors in a file called ‘visitors.txt’. Each line in the file has the following format:

dayOfWeek <space> visitor1,visitor2,..,visitorN.

Identify the error(s) in the code below and write the correct line(s).

    #include <iostream>
    #include <string>
    using namespace std;
    
    int main()
    {
        ifstream my_file("visitors.txt"); 
        string full_line;
        string days[] = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday"};
        int vis[5] = {0, 0, 0, 0, 0}; 
        int i = 0;
        int traffic = 0;
        int j = 0;
    
        while (getline(my_file, full_line))
        {
            for(int i = 0; i < static_cast<int>(full_line.length()); i+=1) 
            {
                if(full_line[i] == ' ' && i < static_cast<int>(full_line.length())-1)
                {
                    visitors[i]++;
                }
                if(full_line[i] == ",") 
                {
                    visitors[i]++;
                }
            }
            if (visitors[i] < traffic) 
            {
                traffic = visitors[i];
                j = i;
            }
            i++;
        }
        cout << days[j] << " is the busiest day of the week at the mueseum." << endl;
    
        return 0;
    }

Recitation Valid Double - Problem 2

Design a function validateDouble that accepts a string input and determines if it represents a valid double by iterating through the string. Valid doubles can start with a minus sign and can have up to one decimal point. Your program should ask the user to input a double, store it as a string and then invoke validateDouble function to check its validity. The program should then print whether the string is a valid double or not. (Negative double are also valid doubles. You can reuse some parts of your validateInt function from week 5 homework.

Function:	`validateDouble(string)` `bool validateDouble(string input)`
Purpose:	Iterate through a string and verify if it is a valid double or not. The function should not print anything.
Parameters:	`string input` - The string to be verified
Return value:	It returns `true` if the string is a valid double. Otherwise, it returns `false`.
Error handling && Boundary conditions:	If length of input = 0, `false` is returned

Expected input/output pairs:

Enter the double:

-123.4

The entered string is a valid double!!

Enter the double:

23.56e