Lab 2 - Classes Overview The Purpose Of This Assignment ✓ Solved

Lab 2 - Classes Overview The purpose of this assignment is t

Lab 2 - Classes Overview The purpose of this assignment is to give you some experience writing classes in C++, including utilizing accessors and constructors to organize data properly.

Description: This program will represent a hypothetical car production line, which consists of a chassis (body of a vehicle) and wheels. These two components will be used to make fully functioning vehicles. To that end, there are three classes you will be writing: Vehicle, Chassis, Wheel. For this assignment, main.cpp will be provided, so focus on the structure of the classes and their interactions.

Chassis: store size (small, medium, large), quality (poor, fair, good), and number of wheels it can support. Number of wheels depends on size: small = 3, medium = 4, large = 6. Default constructor: medium, fair. Provide constructor specifying size, and constructor specifying size and quality. Provide getter getNumWheels().

Wheel: store mileageLeft and condition (poor, fair, good). Default condition is fair. Starting mileage by condition: poor = 5000, fair = 10000, good = 20000. Provide default constructor and constructor to set condition.

Vehicle: store price, wheels (a collection), a Chassis, and isDrivable (bool). The base price for all vehicles is 500. Chassis quality applies a multiplier (poor=5, fair=8, good=12). Each wheel's condition applies a multiplier (poor=1.5, fair=1.8, good=2.2). A vehicle becomes drivable only once the required number of wheels for its chassis has been added.

Required methods:

  • addWheel(): add a Wheel to the vehicle; if max wheels already added, display "You've already added all the wheels!".
  • isBuilt(): return whether the chassis and all wheels have been added.
  • Drive(int miles): if vehicle not built, display "Vehicle not built. Literally un-drivable". Otherwise attempt to travel miles; if miles > minimum mileageLeft among wheels, the vehicle breaks down: display "Broke Down!" and reduce traveled distance accordingly. After every drive print "You've traveled x miles!" where x is actual miles traveled. Update each wheel's mileageLeft and update wheel condition thresholds: >10000 good, >5000 fair, otherwise poor; update vehicle price accordingly when conditions change.
  • getChassis(): return the vehicle's chassis.
  • Display(): print vehicle information, chassis, and wheels.

Example calculation: base 500 chassis multiplier product of wheel multipliers (e.g., 500 12 (1.5 1.5 1.8) ).

Implement classes in C++ using appropriate accessors, constructors, and encapsulation.

Paper For Above Instructions

This paper describes a clear, testable design and implementation strategy for Lab 2: three interrelated C++ classes — Chassis, Wheel, and Vehicle — that model a simplified car production line. The objective is to satisfy the behavioral and structural requirements given in the cleaned assignment text by applying object-oriented principles (encapsulation, single responsibility, and clear interfaces) and using standard library containers where appropriate [1][2].

Design overview

Classes are designed with minimal public interfaces and private state to preserve invariants.

  • Chassis: attributes size (enum), quality (enum), numWheels (int). Default constructor produces medium/fair. Two additional constructors allow size-only and size+quality initialization. A getter getNumWheels() returns the supported wheel count; size-to-wheel mapping is small→3, medium→4, large→6.
  • Wheel: attributes mileageLeft (int) and condition (enum). Default condition is fair, giving 10000 miles. Constructors: default and one that takes a condition to set starting mileage (poor→5000, fair→10000, good→20000). Accessors return current mileage and condition; a mutate method reduceMileage(int) decrements mileage safely to zero and recalculates condition thresholds.
  • Vehicle: attributes basePrice (const double = 500.0), currentPrice (double), chassis (Chassis), wheels (std::vector), and isDrivable (bool). The class exposes addWheel(), isBuilt(), Drive(int), getChassis(), and Display(). Price is recalculated after any structural or condition change according to chassis and wheel multipliers.

Key behavioral rules and mapping

To avoid ambiguity, define the multipliers explicitly:

  • Chassis quality multipliers: poor = 5, fair = 8, good = 12.
  • Wheel condition multipliers: poor = 1.5, fair = 1.8, good = 2.2.

The vehicle's price is computed as basePrice chassisMultiplier product(wheelMultipliers). The vehicle's drivable state is true only when wheels.size() == chassis.getNumWheels(). The addWheel() method must check capacity and print "You've already added all the wheels!" when exceeded.

Drive behavior and wheel condition updates

Drive(int miles) follows this algorithm:

  1. If not isBuilt(), print "Vehicle not built. Literally un-drivable" and return.
  2. Find minMileage = minimum mileageLeft among wheels. If miles > minMileage, set actualMiles = minMileage, print "Broke Down!", otherwise actualMiles = miles.
  3. For each wheel, call reduceMileage(actualMiles). After reduction, recompute its condition using thresholds: >10000 → good, >5000 → fair, else poor. If any wheel's condition changes, trigger a vehicle price recalculation.
  4. Print "You've traveled x miles!" with x = actualMiles.

Note: wheels' mileageLeft must never be negative; reduceMileage enforces this. This approach keeps side effects localized to Wheel and Vehicle methods while keeping invariants obvious [3][4].

Implementation notes and sample pseudocode

Use enums for conditions and sizes to avoid string comparison. Use std::vector<Wheel> for wheel collection and reserve capacity early if chassis is known. Recalculate price via a dedicated private method updatePrice(). Keep console messages exact to the assignment text for automated testing compatibility.

Example pseudocode for updatePrice():

price = basePrice chassisMultiplier(chassis.quality); for each wheel w in wheels: price = wheelMultiplier(w.condition); currentPrice = price;

Error handling and edge cases

Handle attempts to add wheels beyond chassis capacity by printing the specified message and returning without change. Driving zero or negative miles should be treated as zero travel and still print "You've traveled 0 miles!" unless vehicle is not built. All public methods which mutate state should preserve class invariants (wheels.size() ≤ chassis.getNumWheels(), mileageLeft ≥ 0).

Testing and verification

Unit tests should exercise: default construction for each class, parameterized constructors, adding wheels up to capacity and beyond, price calculations for representative mixes of wheel conditions and chassis qualities, Drive() behavior when a wheel causes breakdown, and dynamic condition transitions that change price. Logging exact message strings ensures compatibility with the expected output in main.cpp.

Why this design?

Separating Wheel and Chassis responsibilities from Vehicle follows single responsibility and keeps each class small and verifiable. Using enums and accessor methods improves type safety and clarity; std::vector provides dynamic storage of wheels while exposing simple capacity checks [5][6]. The updatePrice() and reduceMileage() helpers encapsulate frequently used logic and improve reuse and testability [7].

Conclusion

The described C++ class design satisfies the assignment requirements: proper constructors, getters, behavioral methods (addWheel, isBuilt, Drive, getChassis, Display), and explicit price/condition rules. Provided implementation details and tests support robust, maintainable code consistent with modern C++ best practices [8][9][10].

References

  1. Stroustrup, B. The C++ Programming Language. 4th ed. Addison-Wesley, 2013.
  2. Sutter, H., & Alexandrescu, A. C++ Coding Standards: 101 Rules, Guidelines, and Best Practices. Addison-Wesley, 2005.
  3. Meyers, S. Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14. O'Reilly, 2014.
  4. ISO/IEC. ISO/IEC 14882:2017 — Programming languages — C++. International Organization for Standardization, 2017.
  5. cppreference.com. "std::vector - cppreference.com". https://en.cppreference.com/w/cpp/container/vector
  6. cppreference.com. "Enumerations - cppreference.com". https://en.cppreference.com/w/cpp/language/enum
  7. Google C++ Style Guide. "Functions". https://google.github.io/styleguide/cppguide.html
  8. Josuttis, N.M. The C++ Standard Library: A Tutorial and Reference. 2nd ed., Addison-Wesley, 2012.
  9. Sutter, H. "GotW #86: Inner and Outer Exceptions" (Guidelines and design discussion). https://herbsutter.com/
  10. Beazley, D. Python/C++ Interfacing and software design discussions (design patterns relevant to small class composition). Various conference papers, 2010–2020.

Related Assignments