(Invoice Class) Create a class called Invoice that a hardware store might use to represent an invoice for an item sold at the store. An Invoice should include four data members -a part number (type string), a part description (type string), a quantity of the item being purchased (type int) and a price per item (type int). [Note: In subsequent chapters, we'll use numbers that contain decimal points (e.g., \(2.75)\) - called floating-point values - to represent dollar amounts.] Your class should have a constructor that initializes the four data members. Provide a set and a get function for each data member. In addition, provide a member function named getInvoiceAmount that calculates the invoice amount (i.e., multiplies the quantity by the price per item), then returns the amount as an int value. If the quantity is not positive, it should be set to 0. If the price per item is not positive, it should be set to 0. Write a test program that demonstrates class Invoice's capabilities.

When learning C++, one of the essential examples of practical object-oriented programming is implementing an Invoice Class. Such a class is designed to mimic a real-world invoice system, relevant for a hardware store or any retail business context.
An Invoice Class in C++ typically includes data members to represent key details of a sale, such as part number, part description, quantity, and price per item. By declaring these attributes as private, we ensure that direct access from outside the class is restricted, promoting secure and controlled handling of data. Constructors and member functions such as 'set' and 'get' methods enhance interaction with the data, while a specialized member function, often called getInvoiceAmount, computes the total cost by multiplying the quantity and price per item.
While implementing this class, verifying inputs to ensure valid data is crucial. This is where 'set' functions come into play, enforcing positive values for quantities and prices. Integrating data validation steps directly into the class design ensures that the object maintains a valid state throughout its lifecycle.

Object-Oriented Programming (OOP) is a paradigm centered around objects which are instances of classes. Classes act as blueprints defining the structure and behavior of objects.
Using OOP concepts such as encapsulation, inheritance, and polymorphism, C++ allows developers to build modular, reusable, and adaptable code. In our Invoice class example, the class encapsulates all the necessary attributes and behaviors relevant to an invoice, and by doing so, it aligns with the OOP principle of packaging data and functionalities together. OOP facilitates easier maintenance and a more straightforward approach to reasoning about complex systems, making it a cornerstone for modern software development.

Data encapsulation is an OOP concept that refers to the bundling of data with the methods that operate on that data. It restricts direct access to some of an object’s components, which is a fundamental part of encapsulation.
In C++, we encapsulate data by marking class attributes as private, meaning they cannot be accessed or altered directly from outside the class. This encourages the use of public accessor (get) and mutator (set) methods, which provide controlled ways of obtaining and modifying private data. This level of control guards against unauthorized access and invalid alterations to the object's state, contributing to the robustness of the application. For instance, an Invoice class encapsulates details about sales transactions, and uses public methods to manage these details safely.

In C++, a constructor is a special member function called when an object is created. It serves to initialize the object's attributes with specific values. In our Invoice class, the constructor ensures that each invoice starts with proper identifiers and financial details, reflecting an accurate invoicing context from the get-go.
Other member functions within a class may include 'setters' and 'getters'—functions that respectively set and retrieve the value of private attributes. These bolster data encapsulation by providing a safe interface for the class’s interaction. Having a dedicated function for calculating the invoice amount, typically named getInvoiceAmount, embodies the class's capacity to carry out operations pertinent to its purpose. The use of constructors and member functions defines object behavior and can verify that the object's state remains valid, which is imperative in producing error-free, reliable software.