What is Operator overloading? Design a Distance class with data members in meters, centimeters, and millimeters. Write a program to overload addition and subtraction operators respectively on Distance class and derive the data members using getter and setter functions. Also, overload the input/output operators for the Distance class.

Operator overloading is a feature in C++ where different operators are used to perform more than one operation. This means that the same operator behaves differently with different types. For example, the '+' operator can be used to add two integers as well as join two strings and merge two lists. It is an example of compile time polymorphism.

In C++, we can overload:

• Unary operators: ++, --, -, !
• Binary operators: +, -, *, /, %, etc.
• Relational operators: ==, !=, <, >, <=, >=
• Logical operators: &&, ||, !
• Assignment operators: =, +=, -=, *=, /=, etc.
• Misc operators: [], (), ->, new, delete, etc.

Now, let's design a Distance class with data members in meters, centimeters, and millimeters. We will overload addition and subtraction operators for this class and derive the data members using getter and setter functions. We will also overload the input/output operators for the Distance class.

#include
using namespace std;

class Distance {
    private:
        int meter;
        int centimeter;
        int millimeter;

    public:
        // Constructor
        Distance(int m=0, int cm=0, int mm=0) : meter(m), centimeter(cm), millimeter(mm) {}

        // Getter functions
        int getMeter() { return meter; }
        int getCentimeter() { return centimeter; }
        int getMillimeter() { return millimeter; }

        // Setter functions
        void setMeter(int m) { meter = m; }
        void setCentimeter(int cm) { centimeter = cm; }
        void setMillimeter(int mm) { millimeter = mm; }

        // Overloading + operator
        Distance operator+(const Distance& d) {
            Distance dist;
            dist.meter = this->meter + d.meter;
            dist.centimeter = this->centimeter + d.centimeter;
            dist.millimeter = this->millimeter + d.millimeter;
            return dist;
        }

        // Overloading - operator
        Distance operator-(const Distance& d) {
            Distance dist;
            dist.meter = this->meter - d.meter;
            dist.centimeter = this->centimeter - d.centimeter;
            dist.millimeter = this->millimeter - d.millimeter;
            return dist;
        }

        // Overloading << operator
        friend ostream& operator<<(ostream& out, const Distance& d) {
            out << d.meter << " meter " << d.centimeter << " centimeter " << d.millimeter << " millimeter";
            return out;
        }

        // Overloading >> operator
        friend istream& operator>>(istream& in, Distance& d) {
            in >> d.meter;
            in >> d.centimeter;
            in >> d.millimeter;
            return in;
        }
};

int main() {
    Distance d1(1, 20, 300);
    Distance d2(2, 40, 600);

    Distance d3 = d1 + d2;
    cout << "Sum: " << d3 << endl;

    Distance d4 = d1 - d2;
    cout << "Difference: " << d4 << endl;

    return 0;
}

In the above program, we have overloaded '+' and '-' operators to perform addition and subtraction of Distance objects. We have also overloaded '<<' and '>>' operators to perform output and input operations on Distance objects. The '<<' operator must be overloaded as a global function, while the '>>' operator can be overloaded as a member function. However, in both cases, it is customary to overload these operators as global functions.