SWEN-250 Activity: Implementing a SimpleString Class

Objective

In this activity, you will implement your own version of a string class in C++. This exercise is designed to give you hands-on experience with:

• C++ classes
• The Rule of Three (copy constructor, copy assignment operator, destructor)
• Dynamic memory management
• Overloading operators (== and <<)
• Basic C-style string handling

Background

In Java and Python, strings are managed objects that handle memory automatically. In C++, while we have std::string, it's important to understand how strings could be implemented behind the scenes — especially in a language where you are responsible for memory management.

This assignment will introduce you to the Rule of Three, which states that if your class allocates dynamic memory, you must explicitly define:

• A copy constructor
• A copy assignment operator
• A destructor

Your Task

You will implement a class called SimpleString that holds a dynamically allocated null-terminated C-style string (i.e., a char*).

You will:

• Manage dynamic memory using new[] and delete[]
• Ensure deep copies in your constructors and assignment operator
• Implement equality and stream insertion operators for testing and output

Files Provided - Download Here

• SimpleString.h — class declaration with TODO comments
• SimpleString.cpp — function stubs with comments
• main.cpp — a test driver using Check() for test output and validation
• Makefile — a file for building the project

Your Implementation Must Include

class SimpleString {
public:
    SimpleString();                          // Default constructor
    SimpleString(const char* text);          // Construct from a C-string
    SimpleString(const SimpleString& other); // Copy constructor
    SimpleString& operator=(const SimpleString& other); // Copy assignment
    bool operator==(const SimpleString& other) const;   // Equality
    ~SimpleString();                         // Destructor

    int Length() const;                      // Get string length

    friend std::ostream& operator<<(std::ostream& os, const SimpleString& str); // Stream output

private:
    char* data;
};

Testing

You will test your implementation using the provided main.cpp. This file uses a custom Check() function to provide [PASS]/[FAIL] results for:

• Creating empty and non-empty strings
• Copy constructor behavior
• Assignment operator behavior
• Deep copy verification
• == operator correctness
• Output using <<

You are encouraged to add your own additional tests as needed!

Rules and Requirements

• You must not use std::string in your implementation.
• You must not use any external libraries (e.g., no strcpy, no strcmp, no strlen!!!).
• Your class must follow the Rule of Three.
• Your code must compile with g++ -std=c++11 or later.
• You should see Destructor called, Assignment operator called, etc., printed to the terminal to help trace program behavior.

Submission

Submit via Gitlab in a directory called SimpleString

Ensure your submission compiles and runs cleanly with no memory leaks.