Здравствуйте, Посетитель - 383089!

Вот вариант решения Вашей задачи. Символы хранятся в статическом массиве, максимальная длина массива ограничена статической константой. Реальная длина множества на каждый момент времени определяется полем power.
Недопустимость повторных символов в множестве учитывается на этапах добавления и инициализации.
Операторы +, - и * реализованы как дружественные функции, как и операторы ввода-вывода.
Дополнительно для удобства добавила оператор присваивания и конструктор копирования.

Работу класса можно проверить на таком примере:


Если Вам нужна какая-то более конкретная программа, использующая данный класс, пишите.
Проверено в VS 2010. Код в приложении и в приложенном архиве, из комментариев должно быть всё понятно.

Удачи!

Приложение:
//Set.h
#pragma once
#include <iostream>
using namespace std;

class Set
{
static const int max_power = 100; //максимальная мощность
char set [max_power]; //массив символов
int power; //мощность
public:
Set () : power(0) {}; //• пустой конструктор для инициализации экземпляров и массивов экземпляров класса по умолчанию;
Set (const Set& s); //конструктор копирования
Set (int p); //• создание экземпляров класса с инициализацией мощностью множества (начальное множество - символы, начиная с символа пробел);
Set (char* str);//• создание экземпляров класса с инициализацией значениями элементов множества как строки символов;
~Set () {}; //деструктор

Set& operator = (const Set& s); //оператор присваивания
Set& operator += (const char e);//• добавление нового элемента в множество (с помощью перегруженного оператора += );
bool In (char e) const;//• определение, имеется ли некоторый заданный элемент в множестве.

friend Set operator - (const Set &p1, const Set &p2); //• вычисление разности двух множеств (с помощью перегруженного оператора вычитания -; результирующее множество должно состоять из элементов первого множества без тех, которые есть во втором множестве);
friend Set operator * (const Set &p1, const Set &p2); //• вычисление пересечения двух множеств (с помощью перегруженного оператора умножения *; результирующее множество должно состоять из элементов, имеющихся и в множестве 1, и в множестве 2);
friend Set operator + (const Set &p1, const Set &p2); //• объединение двух множеств (с помощью перегруженного оператора сложения +; результирующее множество должно содержать элементы множества 1 и отличающиеся элементы множества 2);
friend istream & operator >> ( istream & in, Set & p ); // ввод экземпляров класса из входного потока
friend ostream & operator << ( ostream & out, const Set & p ); // вывод в выходной поток
};

//Set.cpp

#include "Set.h"

Set::Set (const Set& s)
{
power = s.power; //копируем мощность
memcpy (set, s.set, sizeof(char)*power); //копируем данные
}

Set::Set (int p)
{
if (p>max_power) { //если переданная мощность больше максимальной
power = 0; //инициализируем по умолчанию
return;
}
power = p; //сохраняем мощность
for (int i = 0; i<p; i++) //заполняем символами от пробела
set[i] = ' '+i;
}

Set::Set (char* str)
{
power = 0; //обнуляем мощность
int len = strlen (str); //получаем длину строки
if (len > max_power) return; //если она больше максимальной - выходим
for (int i = 0; i<len; i++) //Заполняем символами из строки
*this+=str[i];
}

Set& Set::operator = (const Set& s)
{ //аналогично конструктору копирования
power = s.power;
memcpy (set, s.set, sizeof(char)*power);
return *this;
}

Set& Set::operator += (const char e)
{
if (power+1>max_power || In(e)) return *this; //если максимальная мощность достигнута или такой элемент уже есть - выходим
set[power] = e; //Добавляем в конец
power++; //увеличиваем мощность
}

bool Set::In (char e) const
{
for (int i = 0; i<power; i++) //ищем символ в массиве
if (set[i] == e) return true; //нашли - возвращаем 1
return false; //не нашли - 0
}

Set operator - (const Set &p1, const Set &p2)
{
Set tmp; //буфер
for (int i = 0; i<p1.power; i++) //идём по символам первого множества
if (!p2.In(p1.set[i])) tmp+=p1.set[i]; //если символ первого не содержится во втором, добавляем к результату
return tmp; //возвращаем буфер
}

Set operator * (const Set &p1, const Set &p2)
{
Set tmp;
for (int i = 0; i<p1.power; i++) //если символ первого содержится во втором, добавляем к результату
if (p2.In(p1.set[i])) tmp+=p1.set[i];
return tmp;
}

Set operator + (const Set &p1, const Set &p2)
{
Set tmp;
for (int i = 0; i<p1.power; i++) //просто добавляем к результату все символы первого и второго множеств
tmp+=p1.set[i]; //повторные не добавятся из-за реализации оператора +=
for (int i = 0; i<p2.power; i++)
tmp+=p2.set[i];
return tmp;
}

istream & operator >> ( istream & in, Set & p )
{
cout << "Enter power: ";
in >> p.power;
cout << "Enter chars: ";
for (int i=0; i<p.power; i++)
in >> p.set[i];
return in;
}

ostream & operator << ( ostream & out, const Set & p )
{
out << "{ ";
for (int i = 0; i<p.power-1; i++)
out << p.set[i] << ", ";
out << p.set[p.power-1] << " }";
return out;
}