Question

Write a \(\mathrm{C}++\) class, AllKinds, that has three member variables of type int. Iong, and float, respectively. Each class must include a constructor function that initializes each variable to a nonzero value, and each class should include functions for setting the value of each type, getting the value of each type, and computing and returning the sum of each possible combination of types.

Short answer

Define the class and its variables, create a constructor, add setters and getters, and implement sum functions.

Step-by-step solution

Define the class

Define the class AllKinds which includes the member variables for int, long, and float.

Add member variables

Declare the three member variables within the class: an int, a long, and a float.

Create the constructor

Implement the constructor to initialize each member variable to a nonzero value.

Add setter functions

Write the setter functions: setInt, setLong, and setFloat, to set values for each member variable.

Add getter functions

Write the getter functions: getInt, getLong, and getFloat, to retrieve the values of each member variable.

Sum functions

Implement functions to compute and return the sum of each combination of the member variables. Create functions for int + long, int + float, long + float, and int + long + float.

Key concepts

Member Variables

Member variables are the attributes that define the properties of a class. In the context of the AllKinds class, we have three member variables: an int, a long, and a float. These variables are declared within the class, and each instance of the class will have its own copy of these variables. For example, you might declare member variables like this inside the class definition:
class AllKinds {
private:
int myInt;
long myLong;
float myFloat;
};
This ensures that each AllKinds object has space for an integer, a long, and a floating-point number.

Constructor Function

A constructor function is a special type of function in C++ used to initialize objects. It has the same name as the class and no return type. Its main purpose is to set initial values for the member variables when an object of the class is created.
In the AllKinds class, the constructor is used to initialize the int, long, and float variables to non-zero values:
AllKinds(int i, long l, float f) {
myInt = i;
myLong = l;
myFloat = f;
}
Whenever you create an object like this: AllKinds ak(1, 100L, 1.5f);, the values of myInt, myLong, and myFloat will be initialized to 1, 100, and 1.5 respectively.

Setter and Getter Functions

Setter and getter functions are used to modify and access the private member variables from outside the class. These functions help in maintaining encapsulation.

**Setters:**
Setter functions allow us to set the values of the member variables. For example:
void setInt(int i) {
myInt = i;
}
void setLong(long l) {
myLong = l;
}
void setFloat(float f) {
myFloat = f;
}

**Getters:**
Getter functions allow us to access the values of the member variables. For example:
int getInt() { return myInt; }
long getLong() { return myLong; }
float getFloat() { return myFloat; }
Using these functions, you can read and modify the values of the member variables without directly accessing them.

Sum Computation

In the AllKinds class, we need functions to compute and return the sum of various combinations of the member variables. This involves simple arithmetic operations.
For example, to compute the sum of the int and long member variables:
long sumIntLong() {
return myInt + myLong;
}
Similarly for int and float:
float sumIntFloat() {
return myInt + myFloat;
}
And for all three:
float sumAll() {
return myInt + myLong + myFloat;
}
These functions provide a straightforward mechanism to perform arithmetic operations using the class's member variables, aiding in computations involving these data types.