Программирование логических операций на множестве латинских букв

Разработать ООП для объединения 2-х любых подмножеств латинских букв, которые передаются ей через аргументы командной строки. Полученный результат должен отображаться строкой стандартного вывода, где все буквы перечислены в алфавитном порядке. Программная реализация вычислений должна быть основана на разработке класса множества латинских букв. При этом состав множества кодируется двоичными разрядами целого числа без знака в приватном поле данных этого класса, а публичный компонентный метод предназначается для перегрузки оператора ‘ +’ в операции объединения 2-х множеств. Конструктор класса должен обеспечивать преобразование символьной записи множества в двоичный целочисленный формат. Необходимо также предусмотреть дружественную перегрузку оператора ‘ <<’ потока стандартного вывода или компонентный оператор преобразования типа множества в символьную строку для отображения объектов класса множества латинских букв.

 

//Перегрузка объединения подмножеств латинских букв

#include <ctype>

#include <iostream>

using namespace std;

class Alpha{//класс множества латинских букв

private:

unsigned bin; //бинарный код подмножества латинских букв

public:

Alpha() {bin=0;};

Alpha(Alpha& y) {bin=y.bin;};

Alpha(char*);

Alpha operator +(Alpha&);

operator char*();

friend ostream& operator << (ostream&,Alpha&);

};// Alpha

//конструктор множества букв по строке

Alpha::Alpha(char* s){

bin=0;

while(*s){

bin | = (1 << (tolower(*s)-'a')); s++;}

}//Alpha

//оператор объединения подмножеств букв

Alpha Alpha:: operator+(Alpha& y){

Alpha z;

z.bin=bin | y.bin;

return(z);}//operator+

//оператор вывода подмножеств букв

ostream& operator << (ostream& out,Alpha& z){

unsigned bit=1;

int i;

for(i=0; i<26;i++){

if((z.bin& bit)>0)

out<<(char)('a'+i);

bit=bit<<1;

}

return out;}// operator <<

//оператор преобразования множества в строку

Alpha::operator char*(){

static char s[32];

unsigned b=bin;

int i=0;

int j=0;

int w;

while(w>0){

if(w & 1)

s[j++]='a'+i;

i++;

w>>1;

}//while

s[j]='\0';

return (s);

}//operator char*()

//основная функция

int main (int argc,char* argv[]){

Alpha x(argv[1]); //буквы 1-го аргумента

Alpha y(argv[2]); //буквы 2-го аргумента

Alpha z; //буквы результата

z=x+y; // объединение подмножеств букв

cout<<z; // или cout<<(char*)z;

return (0);

}//main

Варианты заданий для четвертой лабораторной работы

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для вычисления разности двух любых подмножеств латинских букв, которые заданы двумя символьными строками аргументов команды ее вызова. Искомую разность образуют все буквы первого подмножества, которые отсутствуют во втором. Полученный результат должен отображаться строкой стандартного вывода, где все буквы перечислены в алфавитном порядке. Программная реализация вычислений разности должна быть основана на разработке класса множества латинских букв с компонентным методом перегрузки оператора '−' и полем приватных данных, где состав множества фиксируется двоичными разрядами целого числа без знака. Конструктор класса должен обеспечивать преобразование исходной символьной записи множества в двоичный целочисленный формат. Следует также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B1

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу вычисления симметрической разности двух любых подмножеств латинских букв, которые передаются ей аргументами командной строки. Такую разность образуют все различные буквы из двух заданных подмножеств. Полученный результат должен отображаться строкой стандартного вывода, где все буквы перечислены в алфавитном порядке. Программный код должен быть основан на разработке класса множества латинских букв с компонентными методами перегрузки операторов '+' и '−' для выполнения теоретико-множественных операций объединения двух разностей. Они должны быть ориентированы на обработку поля приватных данных, где состав множества фиксируют двоичные разряды целого числа. Конструктор этого класса должен обеспечивать преобразование исходной символьной записи множества в двоичный целочисленный формат. Необходимо также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B2

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для вычисления дополнения до полного алфавита любого подмножества латинских букв, которое задается символьной строкой в аргументе командной строки ее вызова. Результатом этой операции должны быть все буквы латинского алфавита, кроме тех, которые указаны в аргументе программы. Полученное дополнение должна отображать строка стандартного вывода, где все буквы перечислены в алфавитном порядке. Программная реализация таких вычислений должна быть основана на разработке класса множества латинских букв с компонентным методом для перегрузки оператора '~' и полем приватных данных, где состав множества кодируется двоичными разрядами целого числа. Конструктор класса должен обеспечивать преобразование исходной символьной записи множества в двоичный целочисленный формат. Необходимо также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B3

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для перечисления всех латинских букв, которые отсутствуют в двух любых символьных строках, заданных аргументами команды ее вызова. Искомый результат должна отображать строка стандартного вывода, где все буквы перечислены в алфавитном порядке. Программная реализация таких перечислений должна быть основана на разработке класса множества латинских букв с компонентными методами перегрузки операторов '~' и '+' для выполнения теоретико-множественных операций дополнения и объединения. Они должны быть ориентированы на обработку поля приватных данных, где состав множества фиксируется двоичными разрядами целого числа без знака. Конструктор класса должен обеспечивать преобразование исходной символьной записи множества в двоичный целочисленный формат. Следует также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B4

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для перечисления всех латинских букв кроме тех, которые совпадают в двух любых символьных строках, заданных аргументами команды ее вызова. Искомый результат должна отображать строка стандартного вывода, где все буквы перечислены в алфавитном порядке. Программная реализация таких перечислений должна быть основана на разработке класса множества латинских букв с компонентными методами перегрузки операторов '*' и '~' для выполнения теоретико-множественных операций пересечения и дополнения двух множеств. Они должны быть ориентированы на обработку поля приватных данных, где состав множества фиксируется двоичными разрядами целого числа без знака. Конструктор класса должен обеспечивать преобразование исходной символьной записи множества в двоичный целочисленный формат. Следует также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B5

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу вычисления дополнения до полного алфавита разности двух заданных подмножеств латинских букв, которые передаются ей через аргументы командной строки. Результатом этой операции должны быть все латинские буквы, кроме тех, которые имеются только в первом аргументе. Они должны отображаться строкой стандартного вывода, где все буквы перечислены в алфавитном порядке. Программа должна быть основана на разработке класса множества латинских букв с компонентными методами перегрузки операторов '~' и '−' для выполнения операций дополнения и разности. Они должны быть ориентированы на обработку поля приватных данных, где состав множества фиксируется двоичными разрядами целого числа без знака. Конструктор класса должен обеспечивать преобразование исходной символьной записи множества в двоичный целочисленный формат. Следует также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B6

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для исключения всех латинских букв, по которым совпадают два любых их подмножества, заданные двумя символьными строками в аргументах команды ее вызова. Все оставшиеся различные буквы должны отображаться строкой потока стандартного вывода, где они перечисляются в алфавитном порядке. Программная реализация такого исключения совпадений должна базироваться на разработке класса множества латинских букв с компонентным методом перегрузки оператора '^' и полем приватных данных, где состав множества кодируется двоичными разрядами целого числа без знака. Конструктор этого класса должен обеспечивать преобразование исходной символьной записи подмножества латинских букв в бинарный целочисленный формат. Необходимо также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B7

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для перечисления всех латинских букв, которые одновременно отсутствуют или совпадают в двух любых их подмножествах, заданных двумя символьными строками аргументов команды ее вызова. Искомый результат должна отображать строка стандартного вывода, где все буквы перечислены в алфавитном порядке. Программная реализация таких перечислений должна быть основана на разработке класса множества латинских букв с компонентными методами перегрузки операторов '^' и '~' для выполнения теоретико-множественных операций исключения совпадений и дополнения. Обе они должны быть ориентированы на обработку поля приватных данных, где состав множества фиксируется двоичными разрядами целого числа без знака. Конструктор класса должен обеспечивать преобразование исходной символьной записи множества в двоичный целочисленный формат. Следует также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B8

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу вычисления пересечения двух любых подмножеств латинских букв, которые передаются ей через аргументы командной строки. Полученный результат должен отображаться строкой потока стандартного вывода, где все буквы перечислены в алфавитном порядке. Программная реализация вычислений должна быть основана на разработке класса множества латинских букв с компонентным методом перегрузки оператора '*' для выполнения теоретико-множественной операций пересечения двух множеств. Она должны быть ориентированы на обработку поля приватных данных, где состав множества фиксируется двоичными разрядами целого числа без знака. Конструктор класса должен обеспечивать преобразование исходной символьной записи множества в двоичный целочисленный формат. Необходимо также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B9

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для перечисления всех латинских букв, которые отсутствуют в двух любых символьных строках, заданных аргументами команды ее вызова. Искомый результат должна отображать строка стандартного вывода, где все буквы перечислены в алфавитном порядке. Программная реализация таких перечислений должна быть основана на разработке класса множества латинских букв с компонентными методами перегрузки операторов '*' и '~' для выполнения теоретико-множественных операций пересечения дополнений двух множеств. Они должны быть ориентированы на обработку поля приватных данных, где состав множества фиксируется двоичными разрядами целого числа. Конструктор класса должен обеспечивать преобразование исходной символьной записи множества в двоичный целочисленный формат. Необходимо также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B10

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для перечисления всех латинских букв кроме тех, которые совпадают в двух любых символьных строках, заданных аргументами команды ее вызова. Искомый результат должна отображать строка стандартного вывода, где все буквы перечислены в алфавитном порядке. Программная реализация таких перечислений должна быть основана на разработке класса множества латинских букв с компонентными методами перегрузки операторов '+' и '~' для выполнения теоретико-множественных операций объединения дополнений двух множеств. Они должны быть ориентированы на обработку поля приватных данных, где состав множества фиксируется двоичными разрядами целого числа. Конструктор класса должен обеспечивать преобразование исходной символьной записи множества в двоичный целочисленный формат. Необходимо также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B11

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для перечисления всех латинских букв, кроме тех, которые есть только в первой из двух символьных строк, заданных аргументами команды ее вызова. Искомый результат должна отображать строка стандартного вывода, где все буквы перечисляются в алфавитном порядке. Программная реализация должна быть основана на разработке класса множества латинских букв с компонентными методами перегрузки операторов '~' и '+' для выполнения теоретико-множественных операций дополнения и объединения. Они должны быть ориентированы на обработку поля приватных данных, где состав множества фиксируется двоичными разрядами целого числа без знака. Конструктор класса должен обеспечивать преобразование исходной символьной записи множества в двоичный целочисленный формат. Следует также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B12

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для вычисления разности двух любых подмножеств латинских букв, которые задают 2 символьные строки аргументов команды ее вызова. Искомую разность образуют все буквы первого подмножества, которые отсутствуют во втором. Полученный результат должен отображаться строкой потока стандартного вывода, где все буквы перечисляются в обратном алфавитном порядке. Программная реализация вычисления разности должна быть основана на разработке класса множества латинских букв с компонентным методом перегрузки оператора '−' и полем приватных данных, где состав множества фиксируется двоичными разрядами целого числа без знака. Конструктор класса должен обеспечивать преобразование исходной символьной записи множества в двоичный целочисленный формат. Следует также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B13

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу вычисления симметрической разности двух любых подмножеств латинских букв, которые передаются ей аргументами командной строки. Такую разность образуют все различные буквы из двух заданных подмножеств. Полученный результат должен отображаться строкой стандартного вывода, где все буквы перечислены в обратном алфавитном порядке. Программный код должен быть основан на разработке класса множества латинских букв с компонентными методами перегрузки операторов '+' и '−' для выполнения теоретико-множественных операций объединения двух разностей. Они должны быть ориентированы на обработку поля приватных данных, где состав множества фиксируют двоичные разряды целого числа. Конструктор класса должен обеспечивать преобразование исходной символьной записи множества в двоичный формат целого числа. Нужно также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B14

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для вычисления дополнения до полного алфавита любого подмножества латинских букв, которое задается символьной строкой в аргументе командной строки ее вызова. Результатом этой операции должны быть все буквы латинского алфавита, кроме тех, которые указаны в аргументе программы. Полученное дополнение должно отображаться строкой стандартного вывода, где все буквы перечислены в обратном алфавитном порядке. Программная реализация этих вычислений должна быть основана на разработке класса множества латинских букв с компонентным методом перегрузки оператора '~' и полем приватных данных, где состав множества кодируется двоичными разрядами целого числа без знака. Конструктор класса должен обеспечивать преобразование исходной символьной записи множества в двоичный целочисленный формат. Следует также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B15

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для перечисления всех латинских букв, которые отсутствуют в двух любых символьных строках, заданных аргументами команды ее вызова. Искомый результат должна отображать строка стандартного вывода, где все буквы перечислены в обратном алфавитном порядке. Программная реализация таких перечислений должна быть основана на разработке класса множества латинских букв с компонентными методами перегрузки операторов '~' и '+' для выполнения теоретико-множественных операций дополнения и объединения. Они должны быть ориентированы на обработку поля приватных данных, где состав множества фиксируется двоичными разрядами целого числа. Конструктор класса должен обеспечивать преобразование исходной символьной записи множества в двоичный целочисленный формат. Следует также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B16

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для перечисления всех латинских букв кроме тех, которые совпадают в двух любых символьных строках, заданных аргументами команды ее вызова. Искомый результат должна отображать строка стандартного вывода, где все буквы перечислены в обратном алфавитном порядке. Программная реализация таких перечислений должна быть основана на разработке класса множества латинских букв с компонентными методами перегрузки операторов '*' и '~' для выполнения операций пересечения и дополнения двух множеств. Они должны быть ориентированы на обработку поля приватных данных, где состав множества фиксируется двоичными разрядами целого числа. Конструктор класса должен обеспечивать преобразование исходной символьной записи множества в двоичный целочисленный формат. Необходимо также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B17

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для вычисления дополнения до полного алфавита разности двух заданных подмножеств латинских букв, которые передаются ей аргументами командной строки. Результатом являются все латинские буквы, кроме тех, которые есть только в первом аргументе. Они должны отображаться строкой стандартного вывода, где все буквы перечислены в обратном алфавитном порядке. Программа должна быть основана на разработке класса множества латинских букв с компонентными методами перегрузки операторов '~' и '−' для выполнения операций дополнения и разности. Они должны быть ориентированы на обработку поля приватных данных, где состав множества фиксируется двоичными разрядами целого числа. Конструктор класса должен обеспечивать преобразование исходной символьной записи множества в двоичный целочисленный формат. Необходимо также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B18

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для исключения всех латинских букв, по которым совпадают два любых их подмножества, заданные двумя символьными строками в аргументах команды ее вызова. Все оставшиеся различные буквы должны отображаться строкой потока стандартного вывода, где они перечислены в обратном алфавитном порядке. Программная реализация такого исключения совпадений должна базироваться на разработке класса множества латинских букв с компонентным методом перегрузки оператора '^' и полем приватных данных, где состав множества кодируется двоичными разрядами целого числа без знака. Конструктор этого класса должен обеспечивать преобразование исходной символьной записи подмножества латинских букв в бинарный целочисленный формат. Необходимо также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B19

--------------------------------------------------------------------------------------------------------------------

Разработать объектно-ориентированную программу для перечисления всех латинских букв, которые одновременно отсутствуют или совпадают в двух любых их подмножествах, заданных двумя символьными строками аргументов команды ее вызова. Искомый результат должна отображать строка стандартного вывода, где все буквы перечислены в обратном алфавитном порядке. Программная реализация таких перечислений должна быть основана на разработке класса множества латинских букв с компонентными методами перегрузки операторов '^' и '~' для выполнения операций исключения совпадений и дополнения. Они должны быть ориентированы на обработку поля приватных данных, где состав множества фиксируется двоичными разрядами целого числа. Конструктор класса должен обеспечивать преобразование исходной символьной записи множества в двоичный целочисленный формат. Необходимо также предусмотреть перегрузку оператора класса потока стандартного вывода для отображения объектов класса множества латинских букв.

B20

--------------------------------------------------------------------------------------------------------------------