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

Обедающие философы - C++

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ Указатели http://www.cyberforum.ru/cpp-beginners/thread186701.html
Вам дан текст. Ваша задача написать функцию, которая должна найти самую длинную последовательность внутри цифры. Вход: Первая строка содержит одну линию, что является не более, чем 1000. Выход: Самая длинная последовательность чисел. Все номера положительные и целые числа Заметим, что выход должны быть представлены как в образце. № INPUT ...
C++ Указатели Напишите функцию, которая будет удалять все слова в данном тексте, что соответствует более чем один раз. Примечание. Программы должны использовать указатель. Вход: Первая строка содержит одну линию, что является не более 1000 знаков с пробелами. Каждое слово не длиннее 30 символов. Выход: Форматированный текст. № INPUT OUTPUT 1 Buffalo... http://www.cyberforum.ru/cpp-beginners/thread186693.html
C++ указатели
Напишите функцию, которая должен найти и вернуть последние слова в данном тексте. Прототип функции должны быть следующие MostRecent недействительными (символ * Текст, слова символ *) В символ слова * Ваш функции должны вернуться последние слова, что occurce в тексте. Ваша программа должна быть не чувствительны к регистру (игнорировать регистр - "может" и "может" те же слова) Вход: Первая...
Указатели (Pointers) C++
Напишите функцию, которая будет заменить все "! Символы с точкой "." . Прототип функции должны быть следующие недействительными заменить (символ источника *, символ Dest *) В символ * Dest программы должны вернуться форматированный текст. Вход: Первая строка содержит одну линию, что является не более 1000 знаков с пробелами Выход: Текст с заменой "!" на "." внутри.
C++ Указатели (Pointers) http://www.cyberforum.ru/cpp-beginners/thread186687.html
Напишите функцию, которая формате указать число, помещая одну пустую строку после каждой 3 цифры. Вход: Первая строка содержит одну линию, что является не более чем на 100 Выход: Отформатированный номер. № INPUT OUTPUT 1 200 200
C++ указатели (Pointers) Напишите функцию, которая будет проверять, если подстрока "IPRE" можно найти в данной линии. Вход: Первая строка содержит одну линию, что является не более чем 1000 Выход: ДА или НЕТ. подробнее

Показать сообщение отдельно
programmerC++
3 / 3 / 1
Регистрация: 04.11.2010
Сообщений: 38
05.11.2010, 18:40  [ТС]     Обедающие философы
KpeHDeJIb, смотрите философы не могут есть вечно, кто то из них по ест и положит вилку следовательно другой начнет есть.

Добавлено через 9 минут
есть ещё такой вариант
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
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
#include <process.h>
#include <stdio.h>
#include<windows.h>
#include<iostream>
#include<time.h>
 
using namespace std;
 
#define N 5             //Число философов
#define LEFT (i-1)%N    //Левый сосед философа с номером i
#define RIGHT (i+1)%N   //Правый сосед философа сномером i
#define THINKING 0      //Философ размышляет
#define HUNGRY 1        //Философ получается получить вилки
#define EATING 2        //Философ ест
                        
int state[N];           //Состояния каждого философа
 
 
struct Philosopher      //Описание философа: номер, алгоритм
{
    int number;
    int algorithm;
};
 
struct Forks            //Описывает количество вилок у философа
{
    int left;           //0-нет вилки 
    int right;          //1-есть вилка
}forks[N];
 
 
CRITICAL_SECTION cs;        //Для критических секций: синхрон. процессов    
CRITICAL_SECTION cs_forks;  //и синхр. вилок
 
HANDLE philMutex[N];    //Каждому философу по мьютексу
HANDLE forkMutex[N];    //и каждой вилке
 
void think(int i)       //Моделирует размышления философа
{
    EnterCriticalSection( &cs );    //Вход в критическую секцию
    cout<<"Philosopher number "<<i<<" thinking"<<endl;
    LeaveCriticalSection( &cs );    //Выход из критической секции
}
 
void eat(int i)         //Моделирует обед философа
{
    EnterCriticalSection( &cs );    //Вход в критическую секцию
    cout<<"Philosopher number "<<i<<" eating"<<endl;
    LeaveCriticalSection( &cs );    //Выход из критической секции
}
 
void test(int i)    //Проверка возможности начать философом обед
{
    if(state[i]==HUNGRY&&state[LEFT]!=EATING&&state[RIGHT]!=EATING)
    {
        state[i]=EATING;
        ReleaseMutex( philMutex[i] );
 
    }
}
 
void take_forks(int i)  //Взятие вилок
{
    EnterCriticalSection( &cs_forks );              //Вход в критическую секцию
    state[i]=HUNGRY;                                //Фиксация наличия голодного философа
    test(i);                                        //Попытка получить две вилки
    LeaveCriticalSection( &cs_forks );              //Выход из критической секции
    WaitForSingleObject( philMutex[i], INFINITE );  //Блокировка если вилок не досталось
 
 
}
 
void put_forks(int i)   //Философ кладет вилки обратно
{
    EnterCriticalSection( &cs_forks );  //Вход в критическую секцию 
    state[i]=THINKING;                  //Философ перестал есть
    test(LEFT);                         //Проверить может ли есть сосед слева
    test(RIGHT);                        //Проверить может ли есть сосед справа
    LeaveCriticalSection( &cs_forks );  //Выход из критической секции
}
 
void take_left_fork(int i)  //Попытка взять левую вилку
{
    EnterCriticalSection( &cs );
    WaitForSingleObject( forkMutex[LEFT], INFINITE );   //Если вилка свободна   
    forks[i].left=1;                                    //Берем ее
    LeaveCriticalSection( &cs );
 
}
 
void put_left_fork(int i)   //Кладем левую вилку
{
    WaitForSingleObject( forkMutex[LEFT], INFINITE );   
    forks[i].left=0;            //Кладем вилку
    ReleaseMutex( forkMutex[LEFT] );
 
}
 
void take_right_fork(int i) //Попытка взять правую вилку
{
    EnterCriticalSection( &cs );
    WaitForSingleObject( forkMutex[RIGHT], INFINITE );  //Если вилка свободна   
    forks[i].right=1;                                   //Берем ее
    LeaveCriticalSection( &cs );
 
}
 
void put_right_fork(int i)  //Кладем правую вилку
{
    WaitForSingleObject( forkMutex[RIGHT], INFINITE );  
    forks[i].right=0;           //Кладем вилку
    ReleaseMutex( forkMutex[RIGHT] );
 
}
int test_fork(int i)    //Проверяем наличи у философа обеих вилок
{
    if(forks[i].left==1&&forks[i].right==1) //Если обе
    {
        ReleaseMutex( forkMutex[LEFT] );    //Разрешаем положить вилки
        ReleaseMutex( forkMutex[RIGHT] );   //
        return 1;                                   //Едим
    }
    else
        return 0;
}
 
DWORD WINAPI philosopher(void *lParam)  //Собственно модель философа
{   
    Philosopher phil=*((Philosopher *)lParam);  //Получаем модель философа
    
    while(1)    //Моделируем обед
    {   //Берем вилки
        if(phil.algorithm==0)   //Берем первой левую вилку
        {
            think(phil.number); //Думаем
            take_left_fork(phil.number);    //Берем левую
            take_right_fork(phil.number);   //и правую вилки
            if(test_fork(phil.number)==1)           //Если обе 
                eat(phil.number);                   //то едим
        }
        else
            if(phil.algorithm==1)   //Берем первую вилку случайно
            {
                int n=rand()%2;
                think(phil.number); //Думаем
                if(n==1)
                {
                    
                    take_left_fork(phil.number);        //Берем вилки случайно
                    take_right_fork(phil.number);
                }
                else
                {
                    take_right_fork(phil.number);
                    take_left_fork(phil.number);
                }
                if(test_fork(phil.number)==1)
                    eat(phil.number);
            }
            else
                if(phil.algorithm==2)   //Берем обе вилки
                {
                    think(phil.number);     //Думаем
                    take_forks(phil.number);//Берем вилки   
                    eat(phil.number);       //Едим
                }
        //кладем вилки
        if(phil.algorithm==0&&forks[phil.number].left==1&&forks[phil.number].right==1)
        {
            put_left_fork(phil.number);     //Кладем левую
            put_right_fork(phil.number);    //и правую по первому алгоритму
        }
        else    //Кладем вилки по второму алгоритму 
            if(phil.algorithm==1&&forks[phil.number].left==1&&forks[phil.number].right==1)
            {
                int n=rand()%2;
                if(n==1)
                {
                    put_left_fork(phil.number);
                    put_right_fork(phil.number);
                }
                else    //Случайным образом
                {
                    put_right_fork(phil.number);
                    put_left_fork(phil.number);
                }
            }
            else
                if(phil.algorithm==2)   //Кладем вилки по третьему алгоритму
                    put_forks(phil.number);
        
        Sleep(10);  //Даем время на переключение контекста
    }
}   
int main()  
{   
    srand(time(NULL));  //Что бы числа были действительно случайными
    Philosopher phil[N];
    for(int i=0; i<N; i++)  //Первоначально у философов нет вилок
    {
        forks[i].left=0;
        forks[i].right=0;
    }
    cout<<"Please input number of algorithm(0-left, 1-random, 2-right: "<<endl;
    for(int i=0; i<N; i++)  //Задаем алгоритмы взятия вилок
    {
        phil[i].number=i;
        cout<<"Philosopher number "<<phil[i].number<<": ";
        cin>>phil[i].algorithm;
    }
    for(int i=0; i<N; i++)  //Создаем мьютексы
    {
        philMutex[i] = CreateMutex( NULL, FALSE, NULL );
        forkMutex[i] = CreateMutex(NULL, FALSE, NULL);
    }
    InitializeCriticalSection( &cs );       //Инициализируем
    InitializeCriticalSection( &cs_forks ); //критические секции
    
    DWORD id[N];        //Идентификаторы потоков
    HANDLE hThread[N];  //Потоки
    for(int i=0; i<N; i++)//Создаем потоки
    {
        hThread[i] = CreateThread(NULL, NULL, &philosopher, &phil[i], NULL, &id[i]);    
        
    }
    Sleep(INFINITE);    //Чтобы потоки успели выполнится с корректными значениями 
    while(1);
}
он решает проблему самоблокировки, но не решает что философы могут питаться только через одного.
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru