Efficient Order Processing with Procedural Programming in C++ for R
June 02, 2024
Key Topics
- How to Do Procedural Programming in C++ to Process Orders for R
- What is this assignment about?
Claim Your Discount Today
Ring in Christmas and New Year with a special treat from www.programminghomeworkhelp.com! Get 15% off on all programming assignments when you use the code PHHCNY15 for expert assistance. Don’t miss this festive offer—available for a limited time. Start your New Year with academic success and savings. Act now and save!
Celebrate the Festive Season with 15% Off on All Programming Assignments!
Use Code PHHCNY15
We Accept
Tip of the day
News
How to Do Procedural Programming in C++ to Process Orders for R
Below is a guideline for procedural programming in C++ to process orders for r. We will show you how to develop the program and the different blocks involved.
What is this assignment about?
This C++ homework will show you the procedure of creating a programme that processes clients’ orders for robots from the robots construction business. We will direct you on how to put together the different pieces of the robot, debugging process, the correct file structures for the customer details, and the file’s organization scheme. We also indicate the different header files involved in the program.
This is the header file of our program. The term "header file" refers to a file with the extension ".h" that contains shared C function declarations and macro definitions. There are two different kinds of header files: those created by the programmer and those provided by our compiler. As with the inclusion of the stdio.h header file, which is included with our compiler, we ask permission to use a header file by including it with the C pre-processing directive #include.
Including a header file is equivalent to duplicating its contents, but we avoid doing this because it will increase the likelihood of errors and is not a good idea to copy header file material into source files, especially if there are numerous source files in a programme.
Maintaining all constants, macros, system-wide global variables, and function prototypes in header files and including them wherever necessary is a straightforward approach in C or C++ systems.
/*
;* Robotics.h
;*
;* Created on: Aug 26, 2022
;* Author: thanh
;*/
#include
#include
using namespace std;
#ifndef ROBOTICS_H_
#define ROBOTICS_H_
// DEFINE some CONSTANT
#define DELIMETER ':'
#define CHAR_END_LINE '.'
// Define class to store the data structure
The C preprocessor is instructed to scan the specified file as input before moving on to the rest of the current source file using the #include directive. The output from the preprocessor is composed of the output that has previously been produced, the output from the included file, the output from the text following the #include directive, and finally the output.
The below block is the structure declaration part in which integer value has been declared (minimum and maximum) and a string
struct PART
{
; ; ; ; char part_code;
; ; ; ; string part_name;
; ; ; ; int minimum;
; ; ; ; int maximum;
; ; ; ; int complexity;
; ; ; ; PART(char c = ' ', string name = "", int min = 0, int max = 0, int comp = 0) {
; ; ; ; ; ; part_code = c;
; ; ; ; ; ; part_name = name;
; ; ; ; ; ; minimum = min;
; ; ; ; ; ; maximum = max;
; ; ; ; ; ; complexity = comp;
; ; ; ; }
};
The below block is for the initialization of the above declared structure. Cust name, prio name and string p is initialized here.
struct CUSTOMER
{
; ; ; ; string cust_name;
; ; ; ; string proj_name;
; ; ; p; string list_of_part;
; ; ; ; CUSTOMER(string cust, string proj, string p) {
; ; ; ; ; ; cust_name = cust;
; ; ; ; ; ; proj_name = proj;
; ; ; ; ; ; list_of_part = p;
; ; ; ; }
};
struct BUILDER
{
; ; ; ; string name;
; ; ; ; int ability;
; ; ; ; int variability;
; ; ; ; BUILDER(string n, int a, int v) {
; ; ; ; ; ; name = n;
; ; ; ; ; ; ability = a;
; ; ; ; ; ; variability = v;
; ; ; ; }
};
// Prototype for functional
vectorparsingPartsData(string);
vectorparsingCustomerData(string);
vectorparsingBuilderData(string);
void buildingRobot(BUILDER, CUSTOMER, vector, ofstream&);
int calculateRobotComplexity(vector, string);
int calculateRobotVariablity(int, string);
#endif /* ROBOTICS_H_ */
This form is used for system header files. It searches for a file named 'file' in a standard list of system directories. You can prepend directories to this list with the -I option while compiling your source code.
The main goal is to develop a programme that carries out the processing of client orders for robots from a robot construction business: ITR (Illawarra Toy Robotics). Customers' orders are used as the basis for the company's robot construction. Each robot is somewhat sophisticated, as would be expected, and will be put together only from pieces kept in the company's inventory. ITR technicians, often known as builders, have a variety of skills. Each builder's ability varies around a fixed value and has an impact on whether or not a robot is successfully built.
/*
;* Robotics.cpp
;*
;* Created on: Aug 26, 2022
;* Author: thanh
;*/
#include
#include
#include
#include
#include
#include
#include "Robotics.h"
using namespace std;
vectorparsingPartsData(string file_name)
{
; ; // A:Head:1:2:15
; ; vectorpart_data;
; ; ifstream input(file_name);
; ; if (input.is_open())
; ; {
; ; ; ; string line;
; ; ; ; while (getline(input, line))
; ; ; ; {
; ; ; ; ; ; stringstream ss(line);
; ; ; ; ; ; if (ss.good())
; ; ; ; ; ; {
; ; ; ; ; ; ; ; string codeStr, nameStr, minStr, maxStr, compStr;
; ; ; ; ; ; ; ; getline(ss, codeStr, DELIMETER);
; ; ; ; ; ; ; ; getline(ss, nameStr, DELIMETER);
; ; ; ; ; ; ; ; getline(ss, minStr, DELIMETER);
; ; ; ; ; ; ; ; getline(ss, maxStr, DELIMETER);
; ; ; ; ; ; ; ; getline(ss, compStr, CHAR_END_LINE);
; ; ; ; ; ; ; ; part_data.push_back(PART(codeStr[0], nameStr, atoi(minStr.c_str()), atoi(maxStr.c_str()), atoi(compStr.c_str())));
; ; ; ; ; ; }
The program continues to take input in the form od data of the customers who want to place order for the robots. It is done by debugging. The program started with the library functions used in cpp. Then we have to connect the code with the header file to run the program without any errors. In the other lines the user continues to take inputs for the customer data.
; ; }
; ; ; ; input.close();
; ; }
// cout << "DEBUG: PARTS DATABASE" << endl;
// for (size_t i = 0; i < part_data.size(); i++)
// {
// cout << "\t" << part_data[i].part_code << " : " << part_data[i].part_name << " : " << part_data[i].minimum << " : "
// << part_data[i].maximum << " : " << part_data[i].complexity << endl;
// }
; ; return part_data;
}
vectorparsingCustomerData(string file_name)
{
; ; // Dodgy Dan:Dog:BCACECC.
; ; vectorcustomer_data;
; ; ifstream input(file_name);
; ; if (input.is_open())
; ; {
; ; ; ; string line;
; ; ; ; while (getline(input, line))
; ; ; ; {
; ; ; ; ; ; stringstream ss(line);
; ; ; ; ; ; if (ss.good())
; ; ; ; ; ; {
; ; ; ; ; ; ; ; string custStr, projStr, listStr;
; ; ; ; ; ; ; ; getline(ss, custStr, DELIMETER);
; ; ; ; ; ; ; ; getline(ss, projStr, DELIMETER);
; ; ; ; ; ; ; ; getline(ss, listStr, CHAR_END_LINE);
; ; ; ; ; ; ; ; customer_data.push_back(CUSTOMER(custStr, projStr, listStr));
; ; ; ; ; ; }
; ; ; ; }
; ; ; ; input.close();
; ; }
// cout << "DEBUG: CUSTOMER DATABASE" << endl;
// for (size_t i = 0; i < customer_data.size(); i++)
// {
// cout << "\t" << customer_data[i].cust_name << " : " << customer_data[i].proj_name << " : " << customer_data[i].list_of_part << endl;
// }
; ; return customer_data;
}
vectorparsingBuilderData(string file_name)
{
; ; // Reliable Rover:70:1.
; ; vectorbuilders_data;
; ; ifstream input(file_name);
; ; if (input.is_open())
; ; {
; ; ; ; string line;
; ; ; ; while (getline(input, line))
; ; ; ; {
; ; ; ; ; ; stringstream ss(line);
; ; ; ; ; ; if (ss.good())
; ; ; ; ; ; {
; ; ; ; ; ; ; ; string nameStr, abiStr, varStr;
; ; ; ; ; ; ; ; getline(ss, nameStr, DELIMETER);
; ; ; ; ; p; ; ; getline(ss, abiStr, DELIMETER);
; ; ; ; ; ; ; ; getline(ss, varStr, CHAR_END_LINE);
; ; ; ; ; ; ; ; builders_data.push_back(BUILDER(nameStr, atoi(abiStr.c_str()), atoi(varStr.c_str())));
; ; ; ; ; ; }
; ; ; ; }
; ; ; ; input.close();
; ; }
// cout << "DEBUG: BUILDER DATABASE" << endl;
// for (size_t i = 0; i < builders_data.size(); i++)
// {
// cout << "\t" << builders_data[i].name << " : " << builders_data[i].ability << " : " << builders_data[i].variability << endl;
// }
; ; return builders_data;
}
Finding the program and try to build the robot for tree time. We have to keep in mind the complexity as well.
There are no more than 10 entries in the file Customers.txt, which houses the customer data. The name of the customer, the title of the project, and the parts needed to complete the order are all disclosed. The file's structure is as follows (fields are separated by colons, and lines are ended by full stops).
void buildingRobot(BUILDER builder, CUSTOMER customer, vectorparts, ofstream &out)
{
; ; int complexity = calculateRobotComplexity(parts, customer.list_of_part);
; ; int variablity = calculateRobotVariablity(builder.variability, customer.list_of_part);
; ; out << "Overall robot complexity = " << complexity << endl;
; ; out << "Overall robot variability = " << variablity << endl;
; ; // Now try to build the robot for tree time.
; int cnt = 0;
; ; while (cnt < 3)
; ; {
; ; ; ; switch (cnt)
; ; ; ; {
; ; ; ; ; ; case 1:
; ; ; ; ; ; ; out << "Attempting the build second times" << endl;
; ; ; ; ; ; ; ; break;
; ; ; ; ; ; case 2:
; ; ; ; ; ; ; ; out << "Attempting the build third times" << endl;
; ; ; ; ; ; ; ; break;
; ; ; ; ; ; default:
; ; ; ; ; ; ; ; break;
; ; ; ; }
The name of the person who placed the order is listed as the Customer. It is a printable string of non-empty characters that might contain white space.
The buyer selects the project name, which is meant to indicate the kind of robot that will be constructed. It is a non-empty string of printable characters that may include spaces, just like the Customer name is.
Each letter on the List of Parts's list of letters corresponds to a part in the Parts File. They don't have to be listed alphabetically. For any order, there shouldn't be more than 10 components.
; ; ; ; default_random_engine randEngine(rand());
; ; ; ; normal_distributionnormal(builder.ability, variablity);
; ; ; ; int randValue = normal(randEngine);
; ; ; ; out << "Normal random value: " << randValue << endl;
; ; ; if ((randValue + (cnt * 10)) >= complexity)
; ; ; ; {
; ; ; ; ; ; out << "Build successful" << endl;
; ; ; ; ; ; break;
; ; ; ; }
; ; ; ; else
; ; ; ; {
; ; ; ; ; ; out << "Build failed" << endl;
; ; ; ; ; ; cnt++;
; ; ; ; }
; ; }
}
int calculateRobotComplexity(vectorparts, string robot_parts)
{
; ; ;Determine the overall robot complexity as 22 plus the sum of the part complexities. For example,
; ; ;given a customer Sally the robot complexity is computed as:
; ; int complex_total = 0;
; ; for (size_t i = 0; i < robot_parts.size(); i++)
; ; {
; ; ; ; PART part_found;
; ; ; ; for (size_t p = 0; p < parts.size(); p++)
; ; ; ; {
; ; ; ; ; ; if (parts[p].part_code == robot_parts[i])
; ; ; ; ; ; {
; ; ; ; ; ; ; ; part_found = parts[p];
; ; ; ; ; ; ; ; break;
; ; ; ; ; ; }
; ; ; ; }
; ; ; ; complex_total += part_found.complexity;
; ; }
; ; if (complex_total + 22 > 100)
; ; ; ; return 100;
; ; return complex_total + 22;
}
int calculateRobotVariablity(int var, string robot_parts)
{
; ; Determine the overall robot variability as 4 plus the number of parts plus the variability of the builder.
; ; // j o h n n y t u o t - g m a i l
; ; return 4 + robot_parts.length() + var;
}
Builders.txt, a file that could have at least one entry and contain information about the potential builders the business could assign to complete an order, is one possible name for this file. Following is the file's organisational scheme (fields are separated by colons, and lines are concluded with full stops):
No empty name will do. The attribute has an inclusive integer value between 1 and 99. A builder's skill may vary around the value given in the record because the variability is an integer with a range of 1 to 10 inclusive.
/*
;* ITR.cpp
;*
;* Created on: Aug 26, 2022
;* Author: thanh
;*/
#include
#include
#include
#include
#include
#include "Robotics.h"
using namespace std;
int main(int argc, char **argv)
{
; ; if (argc != 5)
; ; {
; ; ; ; cout << "Usage: " << argv[0] << " " << endl;
; ; ; ; return 1;
; ; }
; ; vectorpart_data = parsingPartsData(argv[2]);
; ; vectorcust_data = parsingCustomerData(argv[1]);
; ; vectorbuilder_data = parsingBuilderData(argv[3]);
; ; string output_name = argv[4];
; ; ofstream output_file;
; ; output_file.open(output_name);
; ; if (output_file.is_open())
; ; {
; ; ; ; for (size_t i = 0; i < cust_data.size(); i++)
; ; ; ; {
; ; ; ; ; ; random_device device;
; ; ; ; ; ; mt19937 gen(device());
; ; ; ; ; ; uniform_int_distribution<> uniform(0, 2);
; ; ; ; ; int randValue = uniform(gen);
; ; ; ; ; ; output_file << "Processing customer : " << cust_data[i].cust_name << endl;
; ; ; ; ; ; output_file << "Order: " << cust_data[i].proj_name << endl;
; ; ; ; ; ; output_file << "Builder: " << builder_data[randValue].name << endl;
; ; ; ; ; ; buildingRobot(builder_data[randValue], cust_data[i], part_data, output_file);
; ; ; ; ; ; output_file << endl;
; ; ; ; }
; ; ; ; output_file.close();
; ; }
; ; return 0;
}
Similar Blogs
Dynamic Programming for Efficient Path Counting in Connected Graphs in C++
Programming assignments often involve tackling complex and computationally intensive problems, particularly when dealing with recursive solutions. Recursive algorithms, while sometimes straightforward and elegant, can become inefficient when they repeatedly solve the same subproblems. This inef...
Stacks and Queues for Arithmetic Expression Handling and Process Scheduling in C++
Data structures are fundamental building blocks that help us manage and organize data efficiently. Two of the most versatile and commonly used data structures are stacks and queues. These structures are not just theoretical concepts but are used in practical applications ranging from expression...
Dynamic Array in C++ for Data Handling and Memory Efficiency
In many programming scenarios, particularly when dealing with collections of data, efficiently handling an unknown number of elements is crucial. This is where dynamic arrays prove to be highly beneficial. Unlike static arrays, which require a fixed size to be defined upfront, dynamic arrays ca...
Shunting-Yard Algorithm in C++ for Expression Parsing and Postfix Conversion
Parsing and evaluating mathematical expressions efficiently is a fundamental skill in computer science. Whether you're working on a computer science assignment or developing software like calculators or compilers, understanding how to handle expressions is crucial. The shunting-yard algorithm, ...
Virtual Chemical Laboratory Simulation in C++
Imagine having the power to create and manage a chemical laboratory entirely through code. A place where elements are discovered, compounds are synthesized, and every aspect of a chemist's work is simulated in a virtual environment. This kind of project not only stretches the limits of programm...
C++ Assignment: User-Driven Bank Account System Development
Programming assignments involving complex class designs, such as a bank account system, are an excellent way to strengthen your understanding of object-oriented programming and dynamic memory management in C++. These assignments challenge you to create well-structured, efficient, and maintainab...
Solving Binary Manipulation Assignments: Tips and Technique
Binary manipulation assignments are an essential part of programming education, especially for students pursuing computer science and engineering. In order to complete your programming assignments often involve operations on binary numbers, which are the foundation of digital computers and mode...
Developing Interactive Console Games with C++
Developing interactive console games with C++ offers an exciting opportunity to advance programming skills and unleash creative potential, while also providing valuable assistance with C++ assignment. Whether you're just starting or have programming experience, this guide equips you with founda...
Solving Text Analysis Projects with Hash Tables
Programming assignments are a staple in any computer science curriculum. They test not only your understanding of theoretical concepts but also your ability to apply these concepts practically to solve real-world problems. One common type of assignment involves text analysis using hash tables, ...
Improving Marking and Grading with Rubrics: Strategies and Techniques
Effective assessment in education is crucial for evaluating student performance and fostering learning and growth. Educators utilize rubrics as structured scoring guides to assess various types of student work, including essays, projects, presentations, and practical demonstrations. Rubrics enh...
Step-by-Step OOP in C++: Creating an Event Planning System
Object-oriented programming (OOP) assignments in C++ can initially seem daunting due to their complexity and the need to design multiple interconnected classes. However, by breaking down the task into manageable steps and following best practices, you can efficiently tackle such programming ass...
Comprehending Object-Oriented Programming in C++
Object-oriented programming (OOP) is not merely a programming paradigm; it's a mindset, a methodology, and a powerful tool for software development. In the realm of programming languages, C++ stands tall as a stalwart supporter of OOP principles, offering students a robust platform to grasp the...
Mastering Dynamic Memory Management Homework in C++
Memory management is a critical aspect of programming in C++, particularly when dealing with dynamic memory allocation. In this context, dynamic memory refers to memory allocated during program execution, as opposed to static memory allocated during compilation. The efficient and proper handlin...
Understanding C++ Data Types Homework : A Comprehensive Guide
In this comprehensive overview, we delve into the significance of data types in C++ and their vital role in programming. C++ is renowned for its versatility, making it a popular choice for diverse applications, and grasping data types is fundamental to harnessing its potential fully. These data...
Navigating the World of Modern C++: A Guide for University Students
In the dynamic world of programming languages, C++ has consistently proven its resilience and adaptability, standing the test of time as a powerful and versatile coding tool. The release of C++11 and its subsequent iterations marked a pivotal moment in the language's evolution, bringing forth t...
Complete Guide to Using C++ STL for Efficient Homework
In the realm of C++ programming, the Standard Template Library (STL) stands as a powerful and indispensable tool for developers, offering a plethora of pre-implemented templates for containers and algorithms. With the ever-increasing complexity of modern software projects and Homework, masterin...
Unleashing C++ Coding Excellence: A Deep Dive into Software Design Patterns
In the ever-evolving landscape of software development, mastering design patterns is paramount for crafting code that is robust, maintainable, and scalable. This blog delves into the realm of software design patterns, focusing specifically on their application in C++. Adopting an academic approac...
A comparison between Java and C++ for GUI
When it comes to the development of a Graphical User Interface, one of the aspects the programmer should put into consideration is making the interface as user-friendly as possible. This will ensure that any person who uses the application for whom the GUI is designed is able to navigate through the...
A Student's Guide to C++ Brilliance: Templates and Inheritance Explored
In the dynamic landscape of programming languages, C++ remains a stalwart, renowned for its versatility and potency. A crucial asset for university students navigating the intricacies of software development, a profound comprehension of advanced C++ features is imperative. This blog endeavors to ...
Sets, maps and hashing in C++
Sets, maps, and hashing in C++ A set, map, and hash table are data structures used in C + + to map keys to values. Their purpose is to organize data so that programmers can look up values for given keys much faster. These three terms can be confusing for students and novice programmers. That’s why w...