Question

include #include using namespace std; const double X = 13.45; const int Y=34; const … # Rewrite the following program so that it is properly formatted. #include #include using namespace std; const double X = 13.45; const int Y=34; const char BLANK= ' '; int main() {string firstName,lastName;int num; double salary; cout<<"Enter first name: "; cin>> firstName; cout<>lastName;cout<>num;cout<

Short answer

The program is properly formatted with each statement on its own line and clear separation of components for readability.

Step-by-step solution

Organize Includes and Namespace

Start by ensuring the inclusion of libraries and the usage of namespaces are clearly separated and formatted. This will help improve readability and maintainability of the program. ```cpp #include #include using namespace std; ```

Declare Constants with Clear Formatting

Format the constants declarations by placing each declaration on its own line. This separation enhances clarity. ```cpp const double X = 13.45; const int Y = 34; const char BLANK = ' '; ```

Define Main Function Clearly

Begin with a clear definition of the main function, ensuring proper indentation to enhance readability. ```cpp int main() { ```

Initialize Variables

Declare and initialize all necessary variables at the beginning of the main function. Place each variable on a new line with appropriate data types. ```cpp string firstName, lastName; int num; double salary; ```

Accept User Input Cleanly

Ensure each prompt and input operation is on a separate line, with outputs followed by appropriate new lines for better user interface. ```cpp cout << "Enter first name: "; cin >> firstName; cout << endl; cout << "Enter last name: "; cin >> lastName; cout << endl; cout << "Enter a positive integer less than 70: "; cin >> num; cout << endl; ```

Calculate Salary

Calculate the salary using the given formula and maintain the computation on a separate line to ensure logical flow. ```cpp salary = num * X; ```

Output Results Cleanly

Format output statements with proper spacing and ensure readability with sensible concatenations and spacing. ```cpp cout << "Name: " << firstName << BLANK << lastName << endl; cout << "Wages: $" << salary << endl; cout << "X = " << X << endl; cout << "X + Y = " << X + Y << endl; ```

Close Main Function

Conclude the program with a clear return statement and closing brace to ensure proper termination. ```cpp return 0; } ```

Key concepts

C++ syntax

C++ has a structured and well-defined syntax that ensures programs are easy to read and debug. Each C++ program must begin with the include directives, such as `#include ` and `#include `, which allow code to access specific elements like input/output streams and string functions. The `using namespace std;` line facilitates access to the standard library, sparing developers from continuously using the `std::` prefix.
Each line of code follows a strict order crucial for maintaining clarity. Statements are terminated by a semicolon (`;`). Spaces and indentation, although ignored by the compiler, enhance readability and are a part of good coding practice. Ensuring consistent formatting, like aligning opening and closing braces, creates visually clear block structures in any program.

variable declaration

Variables in C++ serve as containers for storing data values. They must be declared with a specific type, such as `int` for integers or `double` for floating-point numbers. Proper variable declaration is central to memory management and clarity in C++.
Declare variables at the beginning of functions to clearly define storage requirements. For instance, the script declares `string firstName, lastName;` and `int num;` at the top, providing clear definitions that allocate the necessary storage space for these types from the beginning. A variable's type cannot change during runtime, ensuring that data integrity is preserved.
This interruption-free declaration before any processing also allows for simpler debugging and program comprehension at an introductory level, as seen in educational contexts.

input/output operations

The input/output operations in C++ facilitate user interaction with a program. The `cin` and `cout` objects, part of the input/output stream provided by the `` library, are primarily used for this purpose.
To receive input from the user, the `cin` is followed by the extraction operator (`>>`) and the variable where the input will be stored. For example, `cin >> firstName;` captures the user's input for the `firstName` variable. Always prompt the user with `cout` before any `cin` operation, such as `cout << "Enter first name: ";`, followed by `cin >> firstName;` which captures their input.
For output, `cout` is used with the insertion operator (`<<`) to display data. Concatenate text and variables as needed, ensuring each output operation is on a separate line for clarity and ease of understanding by the user.

constants in C++

Constants in C++ differ from regular variables by having unchangeable values once initialized. They are declared using the `const` keyword, which ensures data that should not be altered during execution remains static, thus enhancing program stability.
Declaring a constant follows the pattern of `const type name = value;`. For example, `const double X = 13.45;` means `X` will always be 13.45 throughout the program. This immutability makes constants a perfect choice for fixed values that are referenced frequently, like mathematical or scientific constants.
Using constants instead of hardcoding values enhances code readability and maintainability. If a constant value needs updating, it is modified in only one spot in the code, avoiding the risk of inconsistent data due to hardcoded numbers scattered throughout the program.