8.14. Mixed Up Code Practice¶

Let's write the code for the struct definition of song. The song structure will have the instance variables string title, string artist, string album, and int year in that order. Put the necessary blocks of code in the correct order.

```
) #distractor
```
```
int year;
```
```
string album;
```
```
string artist;
```
```
string title;
```
```
string year;  #distractor
```
```
struct song (  #distractor
```
```
struct song {
```
```
struct song {  #distractor
```
```
} #distractor
```
```
};
```

In main, create a song object called fly which holds the data for Frank Sinatra's "Fly Me to the Moon" from his 1964 album "It Might as Well Be Swing". Put the necessary blocks of code in the correct order.

artist.fly = "Frank Sinatra";  #distractor

fly.album = "It Might as Well Be Swing";

```
fly.artist = "Frank Sinatra";
```
```
fly.title = "Fly Me to the Moon";
```
```
fly.year = "1964";  #distractor
```
```
fly.year = 1964;
```
```
int main() {
```
```
song fly;
```
```
song fly;
```

title = "Fly Me to the Moon";  #distractor

```
}
```

Let's write the code for the print_song function. print_song takes a song as a parameter and prints out the instance variables in the following format: "title" by artist (album, year). Put the necessary blocks of code in the correct order.

cout << " (" << album << ", " << year << ")\n";  #distractor

cout << " (" << s.album << ", " << s.year << ")\n";

cout << """ << s.title << "" by " << s.artist;  #distractor

cout << '"' << s.title << "\" by " << s.artist;

cout << '"' << title << "\" by " << artist;  #distractor

cout << title << artist << album << year;  #distractor

```
struct print_song (song s) {
```
```
using std::cout;
```
```
void print_song (song s) {
```
```
}
```

Let's write the code for the struct definition of unicorn. The unicorn structure will have the instance variables name, age, horn_length, hair_color, and is_sparkly in that order. A unicorn's horn length is measured to the nearest tenth of a unit. Put the necessary blocks of code in the correct order.

```
bool is_sparkly;
```
```
double horn_length;
```
```
int age;
```
```
int horn_length;  #distractor
```
```
string hair_color;
```
```
string name;
```
```
struct unicorn {
```
```
Struct Unicorn {  #distractor
```
```
} #distractor
```
```
};
```

Let's write the code for the convert_to_human_age function. convert_to_human_age takes a unicorn as a parameter and returns the equivalent human age. If a unicorn is sparkly, then its equivalent human age is three times its age in unicorn years plus the length of its horn. If a unicorn is not sparkly, then its equivalent human age is four times its age in unicorn years plus twice the length of its horn. Put the necessary blocks of code in the correct order.

```
else {
```
```
if (is_sparkly) {
```
```
if (u.is_sparkly) {
```
```
int convert_to_human_age (unicorn u) {
```
```
int human_years;  #distractor
```
```
return 3 * age + horn_length;
```
```
return 3 * u.age + u.horn_length;
```

return 4 * age + 2 * horn_length;  #distractor

```
return 4 * u.age + 2 * u.horn_length;
```
```
void convert_to_human_age (unicorn u) {
```
```
}
```
```
}
```
```
}
```

Let's write the code for the unicorn_power function. unicorn_power takes a unicorn as a parameter and sets is_sparkly to true and changes the color to rainbow. Put the necessary blocks of code in the correct order.

```
u.color = "rainbow";
```
```
u.color = rainbow;
```
```
u.is_sparkly = true;
```
```
u.is_sparkly == true;
```

void &unicorn_power (unicorn u) {  #distractor

void unicorn_power (unicorn u) {  #distractor

```
void unicorn_power (unicorn& u) {
```
```
}
```

Let's write the code for the struct definitions of address and employee. The address structure will have the instance variables house_number, state (abbreviation), and postal_address in that order. The employee structure will be a nested structure with the instance variables name and address address in that order. Put the necessary blocks of code in the correct order, with address defined before employee.

```
address address;
```
```
address;  #distractor
```
```
employee employee;  #distractor
```
```
int house_number;
```
```
int postal_address;
```
```
string address;  #distractor
```
```
string name;
```
```
string state;
```
```
struct address {
```
```
Struct address {  #distractor
```
```
struct employee {
```
```
Struct employee {  #distractor
```
```
}  #distractor
```
```
};
```
```
};
```

Let's write the code for the print_address function. print_address takes an employee as a parameter and should print out the information of the employee in the following format: name (id) lives at house_number in state, postal_address. Put the necessary blocks of code in the correct order.

cout << e.address.house_number << " in " << e.address.state << ", " << e.address.postal_address << '\n';

cout << e.address.name << " (" << e.address.id << ") lives at ";  #distractor

cout << e.house_number << " in " << e.state << ", " << e.postal_address << '\n';  #distractor

cout << e.name << " (" << e.id << ") lives at ";

cout << e.name << '(' << e.address.id << ") lives at";  #distractor

```
string print_address (employee& e) {
```
```
void print_address (employee e) {
```
```
}
```

Sometimes employees will move around and thus we'll need to update their addresses. Let's write the code for the update_address function. update_address takes an employee and a new address as parameters and sets the employee's address to the new address. Put the necessary blocks of code in the correct order.

```
e.address = a;
```
```
e.address = address;  #distractor
```

e.address.house_number = a.house_number;  #distractor

e.address.house_number = a.house_number;  #distractor

e.address.postal_address = a.postal_address;  #distractor

```
e.address.state = a.state;  #distractor
```

employee update_address (employee e, address a) {  #distractor

void update_address (employee e, address a) {  #distractor

void update_address (employee e, address& a) {  #distractor

void update_address (employee& e, address a) {

```
}
```
```
};  #distractor
```

Q10

Let's write the code for the store_employee_data function. store_employee_data doesn't take any parameters and prompts the user for information regarding their name, id, salary, and address in that order. It then returns an employee object with the stored data. Declare all variables before prompting the user. Put the necessary blocks of code in the correct order.

```
cin >> address.state;
```
```
cin >> e.address.house_number;
```
```
cin >> e.address.postal_address;
```
```
cin >> e.address.state;
```
```
cin >> e.house_number;
```
```
cin >> e.name;
```
```
cout << "What is your full name? ";
```
```
cout << "What is your house number? ";
```

cout << "What is your postal address? ";

```
cout << "What state do you live in? ";
```
```
employee e;
```
```
employee store_employee_data () {
```

employee store_employee_data (employee e) {

```
getline(cin, e.name);
```
```
return e;
```
```
return employee e;
```
```
void store_employee_data () {
```
```
}
```