Форум программистов, компьютерный форум CyberForum.ru

Множества без STL - C++

Восстановить пароль Регистрация
 
Elfenlide
23 / 23 / 1
Регистрация: 15.04.2012
Сообщений: 183
17.09.2012, 02:48     Множества без STL #1
Решаю задачу: ввести н-ое количество множеств и найти их обьединение. Объединение это новое множество в состав которого входят элементы первого второго и n-го множества, если элементы в множествах одинаковые, то их добавлять не надо.
A={1,2,3}
B={2,3,6}
Их обьединение будет C={1,2,3,6}
Я почти сделал программу но не получаеться почему-то обьеденить их нормально...да я бы сказал никак их объеденить не получаеться, помогите дописать пожалуйста:
// PPvIS_laba_1.cpp: определяет точку входа для консольного приложения.
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
#include <iostream>
#include <cstring>
using namespace std;
 
int k=0;
void addSet();
/*-------------класс Множество-----------*/
class Set
{
private:
    char element[100];
public:
    Set()
    {
        element[0]='\0';
    }
    Set(char s[])
    {
        strcpy(element,s);
    }
    void getElement()
    {
        cout<<"Введите элементы множества: ";
        cin>>this->element;
    }
    void showElements()
    {
        static int set_number=1;
        cout<<"Множество "<<set_number<<": "
            <<this->element;
        cout<<endl;
        set_number++;
    }   
    Set united(Set sets[],Set sets1[])
    {
        Set temp;
        temp=strcpy(sets.element,sets1.element);
        return temp;
    }
};
 
int main()
{
    setlocale(0,"");
    addSet();
    return 0;
}
 
/*------------Создание множеств и вывод на экран-----------*/
void addSet()
{
    Set *sets[9];
    char choice;
    
    do 
    {
        sets[k]=new Set;
        sets[k]->getElement();
        k++;
        cout<<"Желаете ли вы добавить ещё одно множество?(Y\\N)"; cin>>choice;
    } while (choice=='y');
 
    for(int i=0;i<k;i++)
    {
        sets[i]->showElements();
    }
    cout<<endl;
    cout<<"Объединение: ";   /*создал новый обьект и запомнил его номер, далее в него sets[p] нужно произвести обьединение всех существующих множеств */
    sets[k]=new Set; k++;
    int p=k;
    for(int m=0;m<k-1;m++)
        sets[p]->united(sets[m],sets[m+1]);
        sets[p]->showElements();
        cout<<endl;
}
Заранее благодарен.
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
alsav22
5282 / 4801 / 442
Регистрация: 04.06.2011
Сообщений: 13,587
17.09.2012, 03:10     Множества без STL #2
Эта строчка неправильная:
C++
1
temp=strcpy(sets.element,sets1.element);
У вас компилятор это пропускает?
Elfenlide
23 / 23 / 1
Регистрация: 15.04.2012
Сообщений: 183
17.09.2012, 03:18  [ТС]     Множества без STL #3
Цитата Сообщение от alsav22 Посмотреть сообщение
Эта строчка неправильная:
C++
1
temp=strcpy(sets.element,sets1.element);
У вас компилятор это пропускает?
нет не пропускает, начал менять в итоге вто так теперь функция выглядит:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
/* цикл запуска функции: */
    for(int m=0;m<k-1;m++)
        sets[p]->united(sets[m]);
/* функция*/
Set united(Set sets[])
    {
        Set temp;
        for (int l=0;l<k-1;l++)
        {
            temp=strcpy(sets[l].element,sets[l+1].element);
        }
        return temp;
    }
так пропускает, но, при выводе именно "объединения" вылетает ошибка.
Что-то не могу я вьехать как сделать, книжку открыл смотрю и вроде правильно делаю, но не выходит то что хочу, пробовал просто писать sets[p]=sets[0], работало, копировало но как их кода видно, копировало только одно множество, а если циклически задавать for(int i=0;i<k-1;i++) sets[p]=sets[i], то ничего не выдаёт,просто пробел после слова "объединение"
alsav22
5282 / 4801 / 442
Регистрация: 04.06.2011
Сообщений: 13,587
17.09.2012, 05:39     Множества без STL #4
Если по быстрому. У вас много разных ошибок. Вот код, наверное, весьма не идеальный. Делает просто слияние множеств, не исключая одинаковые элементы:
Код
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
#include <iostream>
using namespace std;
 
int k=0;
void addSet();
/*-------------класс Множество-----------*/
class Set
{
private:
    char element[100];
    int n;
public:
    Set()
    {
        element[0]='\0';
        n = 0;
    }
    
    Set(char s[])
    {
        strcpy(element,s);
    }
    
    void getElement()
    {
        
        char ch;
        
        do
        { 
        cout << "Введите элементы множества (Enter - выход): ";
        cin.sync();
        cin.get(ch);
        if (ch == '\n') 
        {
            cin.sync(); 
            break;
        }
        element[n] = ch;
        n++;
        while (cin.get() != '\n');
        } while (true);
 
    }
    
    void showElements()
    {
        static int set_number=1;
        cout<<"Множество "<<set_number<<": \n";
        for (int i = 0; i < n; i++)
            cout << element[i] << endl;
        cout<<endl;
        set_number++;
    }   
    
    Set* united(Set *sets, Set *sets1)
    {
        Set *unionset = new Set;
        (unionset -> n) = (sets -> n) + (sets1 -> n);
        int i;
        for (i = 0; i < sets -> n; i++)
            unionset -> element[i] = sets -> element[i];
        for (int j = 0; j < sets1 -> n; j++, i++)
             unionset -> element[i] = sets1 -> element[j];
        return unionset;
    }
};
 
int main()
{
    setlocale(0,"");
    addSet();
 
    system("pause");
    return 0;
}
 
/*------------Создание множеств и вывод на экран-----------*/
void addSet()
{
    Set *sets[9];
    char choice;
    
    do 
    {
        sets[k]=new Set;
        sets[k]->getElement();
        k++;
        cout<<"Желаете ли вы добавить ещё одно множество?(Y\\N)"; 
        cin >> choice;
    } while (choice =='y' || choice == 'Y');
 
    for(int i=0;i<k;i++)
    {
        sets[i]->showElements();
    }
    cout<<endl;
    cout<<"Объединение: ";   /*создал новый обьект и запомнил его номер, далее в него sets[p] нужно произвести обьединение всех существующих множеств */
    sets[k]=new Set; 
    int p=k;
    k++;
    for(int m = 0; m < k-1; m++)
        sets[p] = sets[p]->united(sets[p], sets[m]);
        
    sets[p]->showElements();
    cout<<endl;
}
Elfenlide
23 / 23 / 1
Регистрация: 15.04.2012
Сообщений: 183
17.09.2012, 09:33  [ТС]     Множества без STL #5
Цитата Сообщение от alsav22 Посмотреть сообщение
Если по быстрому. У вас много разных ошибок. Вот код, наверное, весьма не идеальный. Делает просто слияние множеств, не исключая одинаковые элементы.
Спасибо!
alsav22
5282 / 4801 / 442
Регистрация: 04.06.2011
Сообщений: 13,587
17.09.2012, 12:48     Множества без STL #6
Вот эта функция уже будет добавлять в объединение множеств элемент, толко при условии, что такого в нём нет:
Код
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
Set* united(Set *sets, Set *sets1)
    {
        Set *unionset = new Set;
        
        int i = 0;
        for (i = 0; i < sets -> n; i++) // если в объединении, что-то уже есть, то копируем в новое объединение
        {
            unionset -> element[i] = sets -> element[i];
            ++(unionset -> n);
        }
        for (int j = 0; j < sets1 -> n; j++, i++)
        {
                if (sets -> n == 0) // если объединение пустое, то просто добавляем в новое объединение новое множество
                {
                    unionset -> element[i] = sets1 -> element[j];
                    ++(unionset -> n);
                }
                else // если объединение не пустое
                {
                    int flag = 0; // флаг дубликата в объединении 
                    for (int p = 0; p < (unionset -> n); p++) // перебор объединения и сравнение с новым элементом
                        if (unionset -> element[p] == sets1 -> element[j]) // если найден дубликат
                        {
                            flag = 1; 
                            i--;
                            break;
                        }
                    if (flag == 0) // если дубликат не найден, то добавляем новый элемент в объединение
                    {
                        unionset -> element[i] = sets1 -> element[j];
                        ++(unionset -> n);
                    }
                }
        }
        return unionset; // возвращаем новое объединение
    }

Добавлено через 40 минут
Если в каждом из множеств не должно быть дубликатов, то функцию заполнения множества нужно так написать:
Код
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
void getElement()
    {
        char ch;
        do
        { 
        cout << "Введите элементы множества (Enter - выход): ";
        cin.sync();
        cin.get(ch);
        if (ch == '\n') 
        {
            cin.sync(); 
            break;
        }
        int flag = 0; // флаг дубликата
        for (int i = 0; i < n; i++) // перебор множества
        {
            if (element[i] == ch) // если найден дубликат
            {
                flag = 1;
                break;
            }
        }
        if (flag == 0) // если дубликат не найден, то добавляем элемент в множество
        {
            element[n] = ch;
            n++;
        }
        while (cin.get() != '\n');
        } while (true);
 
    }
Elfenlide
23 / 23 / 1
Регистрация: 15.04.2012
Сообщений: 183
17.09.2012, 15:54  [ТС]     Множества без STL #7
Цитата Сообщение от alsav22 Посмотреть сообщение
Вот эта функция уже будет добавлять в объединение множеств элемент, толко при условии, что такого в нём нет:
Код
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
Set* united(Set *sets, Set *sets1)
    {
        Set *unionset = new Set;
        
        int i = 0;
        for (i = 0; i < sets -> n; i++) // если в объединении, что-то уже есть, то копируем в новое объединение
        {
            unionset -> element[i] = sets -> element[i];
            ++(unionset -> n);
        }
        for (int j = 0; j < sets1 -> n; j++, i++)
        {
                if (sets -> n == 0) // если объединение пустое, то просто добавляем в новое объединение новое множество
                {
                    unionset -> element[i] = sets1 -> element[j];
                    ++(unionset -> n);
                }
                else // если объединение не пустое
                {
                    int flag = 0; // флаг дубликата в объединении 
                    for (int p = 0; p < (unionset -> n); p++) // перебор объединения и сравнение с новым элементом
                        if (unionset -> element[p] == sets1 -> element[j]) // если найден дубликат
                        {
                            flag = 1; 
                            i--;
                            break;
                        }
                    if (flag == 0) // если дубликат не найден, то добавляем новый элемент в объединение
                    {
                        unionset -> element[i] = sets1 -> element[j];
                        ++(unionset -> n);
                    }
                }
        }
        return unionset; // возвращаем новое объединение
    }

Добавлено через 40 минут
Если в каждом из множеств не должно быть дубликатов, то функцию заполнения множества нужно так написать:
Код
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
void getElement()
    {
        char ch;
        do
        { 
        cout << "Введите элементы множества (Enter - выход): ";
        cin.sync();
        cin.get(ch);
        if (ch == '\n') 
        {
            cin.sync(); 
            break;
        }
        int flag = 0; // флаг дубликата
        for (int i = 0; i < n; i++) // перебор множества
        {
            if (element[i] == ch) // если найден дубликат
            {
                flag = 1;
                break;
            }
        }
        if (flag == 0) // если дубликат не найден, то добавляем элемент в множество
        {
            element[n] = ch;
            n++;
        }
        while (cin.get() != '\n');
        } while (true);
 
    }
компилируется но, когда множества выводяться то первое и второе множества одинаковые и обьединение одинаковое, что-то не хорошо функция работает....
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
// PPvIS_laba_1.cpp: определяет точку входа для консольного приложения.
#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;
void addSet();
/*-------------класс Множество-----------*/
class Set
{
private:
    char element[100];
public:
    Set()
    {
        element[0]='\0';
    }
    Set(char s[])
    {
        strcpy(element,s);
    }
    void getElement()
    {
        cout<<"Введите элементы множества: ";
        cin>>this->element;
    }
    void showElements()
    {
        static int set_number=1;
        cout<<"Множество "<<set_number<<": {";
        for(int t=0;t<100;t++)
        {       
            if(this->element[t]!='.')
                cout<<this->element[t]<<",";
            else break;
        }
        cout<<"}";
        set_number++;
        cout<<endl;
    }
    void united(Set mas[])
    {
        strcat(this->element,mas->element); 
        for(int t=0;t<100;t++)
        {
            if(this->element[t]=='.')
                this->element[t]=',';
        }
    }
};
 
int _tmain(int argc, _TCHAR* argv[])
{
    setlocale(0,"");
    addSet();
    return 0;
}
 
/*------------Создание множеств и вывод на экран-----------*/
void addSet()
{
    Set *sets[4];
    char choice;
    static int k=0;
    do 
    {
        sets[k]=new Set;
        sets[k]->getElement();
        k++;
        cout<<"Желаете ли вы добавить ещё одно множество?(Y\\N)"; cin>>choice;
    } while (choice=='y');
 
    for(int i=0;i<k;i++)
    {
        sets[i]->showElements();
    }
    cout<<"Объединение: ";
    k++; sets[k]=new Set;
    int p=k;
    sets[p]=sets[0];
    for(int l=1;l<k-1;l++)
    {
        sets[p]->united(sets[l]);
    }
    sets[p]->showElements();
}
Вот мой код, я там накрутил кое-что, уже обьеденить получилось, но к сожалению много запятых лишних и повторяющиеся элементы....как бы это исправить... а-то ваш вариант вообще не фурычит...я вообще придумал кое-что, можно сделать этот char element не 100 а динамический, я с указателями толком не знаком поэтому не знаю как это сделать. Но в теориии если сделать то будет легко обьеденить и не будет лишних элементов, и не будут непонятные элементы выводиться на экран в моей задаче когда выводиться "обьеденение"
alsav22
5282 / 4801 / 442
Регистрация: 04.06.2011
Сообщений: 13,587
17.09.2012, 16:09     Множества без STL #8
Это код неправильно работает ?
Код
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
#include <iostream>
using namespace std;
 
int k=0;
void addSet();
/*-------------класс Множество-----------*/
class Set
{
private:
    char element[100];
    int n;
public:
    Set()
    {
        element[0]='\0';
        n = 0;
    }
    
    Set(char s[])
    {
        strcpy(element,s);
    }
    
    void getElement()
    {
        char ch;
        do
        { 
        cout << "Введите элементы множества (Enter - выход): ";
        cin.sync();
        cin.get(ch);
        if (ch == '\n') 
        {
            cin.sync(); 
            break;
        }
        int flag = 0; // флаг дубликата
        for (int i = 0; i < n; i++) // перебор множества
        {
            if (element[i] == ch) // если найден дубликат
            {
                flag = 1;
                break;
            }
        }
        if (flag == 0) // если дубликат не найден, то добавляем элемент в множество
        {
            element[n] = ch;
            n++;
        }
        while (cin.get() != '\n');
        } while (true);
 
    }
    
    void showElements()
    {
        static int set_number=1;
        cout<<"Множество "<<set_number<<": \n";
        for (int i = 0; i < n; i++)
            cout << element[i] << endl;
        cout<<endl;
        set_number++;
    }   
    
    Set* united(Set *sets, Set *sets1)
    {
        Set *unionset = new Set;
        
        int i = 0;
        for (i = 0; i < sets -> n; i++) // если в объединении, что-то уже есть, то копируем в новое объединение
        {
            unionset -> element[i] = sets -> element[i];
            ++(unionset -> n);
        }
        for (int j = 0; j < sets1 -> n; j++, i++)
        {
                if (sets -> n == 0) // если объединение пустое, то просто добавляем в новое объединение новое множество
                {
                    unionset -> element[i] = sets1 -> element[j];
                    ++(unionset -> n);
                }
                else // если объединение не пустое
                {
                    int flag = 0; // флаг дубликата в объединении 
                    for (int p = 0; p < (unionset -> n); p++) // перебор объединения и сравнение с новым элементом
                        if (unionset -> element[p] == sets1 -> element[j]) // если найден дубликат
                        {
                            flag = 1; 
                            i--;
                            break;
                        }
                    if (flag == 0) // если дубликат не найден, то добавляем новый элемент в объединение
                    {
                        unionset -> element[i] = sets1 -> element[j];
                        ++(unionset -> n);
                    }
                }
        }
        return unionset; // возвращаем новое объединение
    }
};
 
int main()
{
    setlocale(0,"");
    addSet();
 
    system("pause");
    return 0;
}
 
/*------------Создание множеств и вывод на экран-----------*/
void addSet()
{
    Set *sets[9];
    char choice;
    
    do 
    {
        sets[k]=new Set;
        sets[k]->getElement();
        k++;
        cout<<"Желаете ли вы добавить ещё одно множество?(Y\\N)"; 
        cin >> choice;
    } while (choice =='y' || choice == 'Y');
 
    for(int i=0;i<k;i++)
    {
        sets[i]->showElements();
    }
    cout<<endl;
    cout<<"Объединение: ";   /*создал новый обьект и запомнил его номер, далее в него sets[p] нужно произвести обьединение всех существующих множеств */
    sets[k]=new Set; 
    int p=k;
    k++;
    for(int m = 0; m < k-1; m++)
        sets[p] = sets[p]->united(sets[p], sets[m]);
        
    sets[p]->showElements();
    cout<<endl;
}
Миниатюры
Множества без STL  
alsav22
5282 / 4801 / 442
Регистрация: 04.06.2011
Сообщений: 13,587
17.09.2012, 16:15     Множества без STL #9
Это вводилось. Это получилось. Что не устраивает?
Миниатюры
Множества без STL   Множества без STL  
Elfenlide
23 / 23 / 1
Регистрация: 15.04.2012
Сообщений: 183
17.09.2012, 16:39  [ТС]     Множества без STL #10
Цитата Сообщение от alsav22 Посмотреть сообщение
Это вводилось. Это получилось. Что не устраивает?
извеняюсь)))не правельно понял ваш метод ввода, думал можно в строку вводить сразу все элементы,спасибо большое за помощь
Invader_Zim
Twilight Parasite
 Аватар для Invader_Zim
153 / 149 / 2
Регистрация: 21.07.2011
Сообщений: 907
17.09.2012, 16:46     Множества без STL #11
Elfenlide,

Не по теме:

У тебя ник неправильно записан. Elfenlied правильно

Elfenlide
23 / 23 / 1
Регистрация: 15.04.2012
Сообщений: 183
19.09.2012, 18:22  [ТС]     Множества без STL #12
В общем теперь новая проблема\
работаю над "пересечение множеств"
пересечение - множество в которое входят все одинаковые элементы из множеств.
A = [a b c d]
B = [a b g h]
пересечение C = [a b]
уже целый день ищу ошибку но всё компилируеться а выводит пересечение как {}.
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
#include "stdafx.h"
#include <iostream>
using namespace std;
void addSet();
/*-------------класс Множество-----------*/
class Set
{
private:
    char element[100];
    int n;
public:
    Set()
    {
        element[0]='\0';
        n = 0;
    }
 
    Set(char s[])
    {
        strcpy(element,s);
    }
 
    void getElement()
    {
 
        char ch;
 
        do
        { 
            cout << "Введите элементы множества (Enter - выход): ";
            cin.sync();
            cin.get(ch);
            if (ch == '\n') 
            {
                cin.sync(); 
                break;
            }
            element[n] = ch;
            n++;
            while (cin.get() != '\n');
        } while (true);
 
    }
 
    void showElements()
    {
        static int set_number=1;
        cout<<"Множество "<<set_number<<": "; cout<<"{";
        for (int i = 0; i < this->n; i++)
            cout << element[i] <<" ";
        cout<<"}"<<endl;
        set_number++;
    }   
    Set* united(Set *sets, Set *sets1)
    {
        Set *unionset = new Set;
 
        int i = 0;
        for (i = 0; i < sets -> n; i++) // если в объединении, что-то уже есть, то копируем в новое объединение
        {
            unionset -> element[i] = sets -> element[i];
            ++(unionset -> n);
        }
        for (int j = 0; j < sets1 -> n; j++, i++)
        {
            if (sets -> n == 0) // если объединение пустое, то просто добавляем в новое объединение новое множество
            {
                unionset -> element[i] = sets1 -> element[j];
                ++(unionset -> n);
            }
            else // если объединение не пустое
            {
                int flag = 0; // флаг дубликата в объединении 
                for (int p = 0; p < (unionset -> n); p++) // перебор объединения и сравнение с новым элементом
                    if (unionset -> element[p] == sets1 -> element[j]) // если найден дубликат
                    {
                        flag = 1;
                        i--;
                        break;
                    }
                    if (flag == 0) // если дубликат не найден, то добавляем новый элемент в объединение
                    {
                        unionset -> element[i] = sets1 -> element[j];
                        ++(unionset -> n);
                    }
            }
        }
        return unionset; // возвращаем новое объединение
    }
 
    Set* sechenie(Set *sets, Set *sets1)
    {
        Set *perset = new Set;
        int t=0;
        for (int i = 0; i < sets->n; i++)
        {
            for (int j = 0; j < sets1->n; j++) /*если в мас1 есть элемент такой как в мас, то записать этот элемент в perset[], если нету то искать дальше */
            {
                if (sets->element[i] == sets1->element[j])
                {
                    perset->element[t]=sets->element[i];
                    t++;++(perset -> n);
                }
            }
        }
    return perset;
    }
};
void addSet(int& k);
int main()
{
    setlocale(0,"");
    static int k = 0;
    addSet(k);
    return 0;
}
 
/*------------Создание множеств и вывод на экран-----------*/
void addSet(int& k)
{
    Set *sets[9];
    char choice;
 
    do 
    {
        sets[k]=new Set;
        sets[k]->getElement();
        k++;
        cout<<"Желаете ли вы добавить ещё одно множество?(Y\\N)"; 
        cin >> choice; cout<<endl;
    } while (choice =='y' || choice == 'Y');
 
    for(int i=0;i<k;i++)
    {
        sets[i]->showElements();
    }
    cout<<endl;
    cout<<"Объединение: "; 
    sets[k]=new Set; 
    int p=k;
    k++;
    for(int m = 0; m < k-1; m++)
        sets[p] = sets[p]->united(sets[p], sets[m]);
    sets[p]->showElements();
 
    cout<<"Пересечение: ";
    sets[k]=new Set; 
    int s=k;
    k++;
    for(int b = 0; b < k-1; b++)
        sets[s] = sets[s]->sechenie(sets[s], sets[b]);
 
    sets[s]->showElements();
    cout<<endl;
}
Думал может с памятью проблемы какие, там ведь с указателями работа, Но я закоментил функцию объединенияи попробовал оставить только пересечения, в итоге всёравно ничего не вышло, в универе люди кторые вроде хорошо шарят тоже не смогли разобраться...
alsav22
5282 / 4801 / 442
Регистрация: 04.06.2011
Сообщений: 13,587
20.09.2012, 10:09     Множества без STL #13
Добавить в методы класса:
C++
1
2
3
4
int getn()
{
    return n;
}
Метод пересечение:
Код
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// Пересечение ...................................................................
    
    Set* sechenie(Set *sets, Set *sets1)
    {
        Set *perset = new Set;
        
        
        if (sets -> n == 0) // если пересечение пустое, то просто добавляем в новое пересечение новое множество
        { 
            for (int i = 0; i < sets1 -> n; i++)
            {
                 perset -> element[i] = sets1 -> element[i];
                 ++(perset -> n);
            }
            return perset; // возвращаем новое пересечение
        }
        
        // если пересечение не пустое
        for (int j = 0; j < sets1 -> n; j++)
            for (int p = 0; p < (sets -> n); p++) // перебор пересечения и сравнение с новым элементом
                if (sets -> element[p] == sets1 -> element[j]) // если найден дубликат
                {
                    perset -> element[(perset -> n)] = sets -> element[p]; // записываем новый элемент в новое пересечение
                    ++(perset -> n);
                    break;
                }
        
        return perset; // возвращаем новое пересечение
    }


Создание пересечения:
Код
C++
1
2
3
4
5
6
7
8
9
10
11
12
cout<<"Пересечение: ";
    sets[k] = new Set; 
    int s = k;
    k++;
    for(int b = 0; b < k-2; b++)
    {
        sets[s] = sets[s] -> sechenie(sets[s], sets[b]);
        if ((sets[s] -> getn()) == 0) break; // если получено пустое пересечение
    }
 
    sets[s] -> showElements();
    cout << endl;

Все в целом (метод объединение слегка упрощён и добавлен один if() в addSet(), чтобы при одном множестве не выводилось объединение-пересечение):
Код
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
#include <iostream>
using namespace std;
 
int k = 0;
void addSet();
/*-------------класс Множество-----------*/
class Set
{
private:
    char element[100];
    int n;
public:
    Set()
    {
        element[0]='\0';
        n = 0;
    }
    
    Set(char s[])
    {
        strcpy(element,s);
    }
    
    int getn()
    {
        return n;
    }
    
    void getElement()
    {
        char ch;
        do
        { 
        cout << "Введите элементы множества (Enter - выход): ";
        cin.sync();
        cin.get(ch);
        if (ch == '\n') 
        {
            cin.sync(); 
            break;
        }
        int flag = 0; // флаг дубликата
        for (int i = 0; i < n; i++) // перебор множества
        {
            if (element[i] == ch) // если найден дубликат
            {
                flag = 1;
                break;
            }
        }
        if (flag == 0) // если дубликат не найден, то добавляем элемент в множество
        {
            element[n] = ch;
            n++;
        }
        while (cin.get() != '\n');
        } while (true);
 
    }
    
    void showElements()
    {
        static int set_number=1;
        cout<<"Множество "<<set_number<<": \n";
        for (int i = 0; i < n; i++)
            cout << element[i] << endl;
        cout<<endl;
        set_number++;
    }   
 
//Объединение.............................................................   
    Set* united(Set *sets, Set *sets1)
    {
        Set *unionset = new Set;
        
        if (sets -> n == 0) // если объединение пустое, то просто добавляем в новое объединение новое множество
        { 
            for (int i = 0; i < sets1 -> n; i++)
            {
                 unionset -> element[i] = sets1 -> element[i];
                 ++(unionset -> n);
            }
            return unionset; // возвращаем новое объединение
        }
        
        for (int i = 0; i < sets -> n; i++) // если объединение не пустое, то копируем в новое объединение
        {
            unionset -> element[i] = sets -> element[i];
            ++(unionset -> n);
        }
        for (int j = 0; j < sets1 -> n; j++) // добавление новых элементов в объединение
        {
              int flag = 0; // флаг дубликата в объединении 
              for (int p = 0; p < (unionset -> n); p++) // перебор объединения и сравнение с новым элементом
                   if (unionset -> element[p] == sets1 -> element[j]) // если найден дубликат
                   {
                       flag = 1; 
                       break;
                    }
               
               if (flag == 0) // если дубликат не найден, то добавляем новый элемент в объединение
               {
                    unionset -> element[unionset -> n] = sets1 -> element[j];
                    ++(unionset -> n);
               }
          }
        
        return unionset; // возвращаем новое объединение
    }
 
// Пересечение ...................................................................
    
    Set* sechenie(Set *sets, Set *sets1)
    {
        Set *perset = new Set;
        
        if (sets -> n == 0) // если пересечение пустое, то просто добавляем в новое пересечение новое множество
        { 
            for (int i = 0; i < sets1 -> n; i++)
            {
                 perset -> element[i] = sets1 -> element[i];
                 ++(perset -> n);
            }
            return perset; // возвращаем новое пересечение
        }
        
        // если пересечение не пустое
        for (int j = 0; j < sets1 -> n; j++)
            for (int p = 0; p < (sets -> n); p++) // перебор пересечения и сравнение с новым элементом
                if (sets -> element[p] == sets1 -> element[j]) // если найден дубликат
                {
                    perset -> element[(perset -> n)] = sets -> element[p]; // записываем новый элемент в новое пересечение
                    ++(perset -> n);
                    break;
                }
        
        return perset; // возвращаем новое пересечение
    }
 };
 
//............................................................*/
 
int main()
{
    setlocale(0,"");
    addSet();
 
    system("pause");
    return 0;
}
 
/*------------Создание множеств и вывод на экран-----------*/
void addSet()
{
    Set *sets[9];
    char choice;
    
    do 
    {
        sets[k] = new Set;
        sets[k] -> getElement();
        k++;
        cout << "Желаете ли вы добавить ещё одно множество?(Y\\N)"; 
        cin >> choice;
    } while (choice =='y' || choice == 'Y');
 
    for(int i = 0; i < k; i++)
    {
        sets[i] -> showElements();
    }
    if (k != 1)
    {
        cout << endl;
        cout << "Объединение: ";/*создал новый обьект и запомнил его номер, далее в него sets[p] нужно произвести обьединение всех существующих множеств */
        sets[k] = new Set; 
        int p = k;
        k++;
        for(int m = 0; m < k-1; m++)
            sets[p] = sets[p] -> united(sets[p], sets[m]);
        
        sets[p] -> showElements();
        cout << endl;
 
        cout<<"Пересечение: ";
        sets[k] = new Set; 
        int s = k;
        k++;
        for(int b = 0; b < k-2; b++)
        {
            sets[s] = sets[s] -> sechenie(sets[s], sets[b]);
            if ((sets[s] -> getn()) == 0) break; // если получено пустое пересечение
        }
 
        sets[s] -> showElements();
        cout << endl;
    }
}
Elfenlide
23 / 23 / 1
Регистрация: 15.04.2012
Сообщений: 183
20.09.2012, 23:24  [ТС]     Множества без STL #14
Цитата Сообщение от alsav22 Посмотреть сообщение
Добавить в методы класса:
C++
1
2
3
4
int getn()
{
    return n;
}
Метод пересечение:
Код
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// Пересечение ...................................................................
    
    Set* sechenie(Set *sets, Set *sets1)
    {
        Set *perset = new Set;
        
        
        if (sets -> n == 0) // если пересечение пустое, то просто добавляем в новое пересечение новое множество
        { 
            for (int i = 0; i < sets1 -> n; i++)
            {
                 perset -> element[i] = sets1 -> element[i];
                 ++(perset -> n);
            }
            return perset; // возвращаем новое пересечение
        }
        
        // если пересечение не пустое
        for (int j = 0; j < sets1 -> n; j++)
            for (int p = 0; p < (sets -> n); p++) // перебор пересечения и сравнение с новым элементом
                if (sets -> element[p] == sets1 -> element[j]) // если найден дубликат
                {
                    perset -> element[(perset -> n)] = sets -> element[p]; // записываем новый элемент в новое пересечение
                    ++(perset -> n);
                    break;
                }
        
        return perset; // возвращаем новое пересечение
    }


Создание пересечения:
Код
C++
1
2
3
4
5
6
7
8
9
10
11
12
cout<<"Пересечение: ";
    sets[k] = new Set; 
    int s = k;
    k++;
    for(int b = 0; b < k-2; b++)
    {
        sets[s] = sets[s] -> sechenie(sets[s], sets[b]);
        if ((sets[s] -> getn()) == 0) break; // если получено пустое пересечение
    }
 
    sets[s] -> showElements();
    cout << endl;

Все в целом (метод объединение слегка упрощён и добавлен один if() в addSet(), чтобы при одном множестве не выводилось объединение-пересечение):
Код
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
#include <iostream>
using namespace std;
 
int k = 0;
void addSet();
/*-------------класс Множество-----------*/
class Set
{
private:
    char element[100];
    int n;
public:
    Set()
    {
        element[0]='\0';
        n = 0;
    }
    
    Set(char s[])
    {
        strcpy(element,s);
    }
    
    int getn()
    {
        return n;
    }
    
    void getElement()
    {
        char ch;
        do
        { 
        cout << "Введите элементы множества (Enter - выход): ";
        cin.sync();
        cin.get(ch);
        if (ch == '\n') 
        {
            cin.sync(); 
            break;
        }
        int flag = 0; // флаг дубликата
        for (int i = 0; i < n; i++) // перебор множества
        {
            if (element[i] == ch) // если найден дубликат
            {
                flag = 1;
                break;
            }
        }
        if (flag == 0) // если дубликат не найден, то добавляем элемент в множество
        {
            element[n] = ch;
            n++;
        }
        while (cin.get() != '\n');
        } while (true);
 
    }
    
    void showElements()
    {
        static int set_number=1;
        cout<<"Множество "<<set_number<<": \n";
        for (int i = 0; i < n; i++)
            cout << element[i] << endl;
        cout<<endl;
        set_number++;
    }   
 
//Объединение.............................................................   
    Set* united(Set *sets, Set *sets1)
    {
        Set *unionset = new Set;
        
        if (sets -> n == 0) // если объединение пустое, то просто добавляем в новое объединение новое множество
        { 
            for (int i = 0; i < sets1 -> n; i++)
            {
                 unionset -> element[i] = sets1 -> element[i];
                 ++(unionset -> n);
            }
            return unionset; // возвращаем новое объединение
        }
        
        for (int i = 0; i < sets -> n; i++) // если объединение не пустое, то копируем в новое объединение
        {
            unionset -> element[i] = sets -> element[i];
            ++(unionset -> n);
        }
        for (int j = 0; j < sets1 -> n; j++) // добавление новых элементов в объединение
        {
              int flag = 0; // флаг дубликата в объединении 
              for (int p = 0; p < (unionset -> n); p++) // перебор объединения и сравнение с новым элементом
                   if (unionset -> element[p] == sets1 -> element[j]) // если найден дубликат
                   {
                       flag = 1; 
                       break;
                    }
               
               if (flag == 0) // если дубликат не найден, то добавляем новый элемент в объединение
               {
                    unionset -> element[unionset -> n] = sets1 -> element[j];
                    ++(unionset -> n);
               }
          }
        
        return unionset; // возвращаем новое объединение
    }
 
// Пересечение ...................................................................
    
    Set* sechenie(Set *sets, Set *sets1)
    {
        Set *perset = new Set;
        
        if (sets -> n == 0) // если пересечение пустое, то просто добавляем в новое пересечение новое множество
        { 
            for (int i = 0; i < sets1 -> n; i++)
            {
                 perset -> element[i] = sets1 -> element[i];
                 ++(perset -> n);
            }
            return perset; // возвращаем новое пересечение
        }
        
        // если пересечение не пустое
        for (int j = 0; j < sets1 -> n; j++)
            for (int p = 0; p < (sets -> n); p++) // перебор пересечения и сравнение с новым элементом
                if (sets -> element[p] == sets1 -> element[j]) // если найден дубликат
                {
                    perset -> element[(perset -> n)] = sets -> element[p]; // записываем новый элемент в новое пересечение
                    ++(perset -> n);
                    break;
                }
        
        return perset; // возвращаем новое пересечение
    }
 };
 
//............................................................*/
 
int main()
{
    setlocale(0,"");
    addSet();
 
    system("pause");
    return 0;
}
 
/*------------Создание множеств и вывод на экран-----------*/
void addSet()
{
    Set *sets[9];
    char choice;
    
    do 
    {
        sets[k] = new Set;
        sets[k] -> getElement();
        k++;
        cout << "Желаете ли вы добавить ещё одно множество?(Y\\N)"; 
        cin >> choice;
    } while (choice =='y' || choice == 'Y');
 
    for(int i = 0; i < k; i++)
    {
        sets[i] -> showElements();
    }
    if (k != 1)
    {
        cout << endl;
        cout << "Объединение: ";/*создал новый обьект и запомнил его номер, далее в него sets[p] нужно произвести обьединение всех существующих множеств */
        sets[k] = new Set; 
        int p = k;
        k++;
        for(int m = 0; m < k-1; m++)
            sets[p] = sets[p] -> united(sets[p], sets[m]);
        
        sets[p] -> showElements();
        cout << endl;
 
        cout<<"Пересечение: ";
        sets[k] = new Set; 
        int s = k;
        k++;
        for(int b = 0; b < k-2; b++)
        {
            sets[s] = sets[s] -> sechenie(sets[s], sets[b]);
            if ((sets[s] -> getn()) == 0) break; // если получено пустое пересечение
        }
 
        sets[s] -> showElements();
        cout << endl;
    }
}
Спасибо большое, а можно подробнее? вплане, почему именно нужно было добавить этот метод? для чего нужна его работа? а-то мне не понятно.Спасибо!
alsav22
5282 / 4801 / 442
Регистрация: 04.06.2011
Сообщений: 13,587
20.09.2012, 23:37     Множества без STL #15
В функции addSet(), там где создаётся пересечение, нужно было проверить возвращаемое из метода sechenie() пересечение на пустоту, т.е. равно количество элементов в нём 0 или нет. Если 0, то значит в двух множествах не найдено общих элементов, а значит нет смысла просматривать другие множества, пересечения не будет, и нужно прекратить цикл for() и вывести пустое пересечение. Но n находится в приватной части класса, в которую доступ имеют только методы класса. Поэтому пришлось создать метод getn(), который возвращает значение n.
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
20.09.2012, 23:49     Множества без STL
Еще ссылки по теме:

C++ Из текстового файла, состоящего из множества комплексных чисел, получить файл, который содержал бы первые два числа в каждой строке без изменения
C++ STL, множества
STL Пересечение множества и вектора C++

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
Elfenlide
23 / 23 / 1
Регистрация: 15.04.2012
Сообщений: 183
20.09.2012, 23:49  [ТС]     Множества без STL #16
Цитата Сообщение от alsav22 Посмотреть сообщение
В функции addSet(), там где создаётся пересечение, нужно было проверить возвращаемое из метода sechenie() пересечение на пустоту, т.е. равно количество элементов в нём 0 или нет. Если 0, то значит в двух множествах не найдено общих элементов, а значит нет смысла просматривать другие множества, пересечения не будет, и нужно прекратить цикл for() и вывести пустое пересечение. Но n находится в приватной части класса, в которую доступ имеют только методы класса. Поэтому пришлось создать метод getn(), который возвращает значение n.
Понятно, огромное вам спасибо!)
Yandex
Объявления
20.09.2012, 23:49     Множества без STL
Ответ Создать тему
Опции темы

Текущее время: 00:08. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru