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

Строки (преобразование текста) - C++

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ Факториал в С http://www.cyberforum.ru/cpp-beginners/thread69448.html
Помогите пожалуйста написать программку. Надо,чтобы считала: (1+ 1/1*1)*(1+1/2*2)*....*(1+1/n*n)=? Немогу сообразить( Спасибо.
C++ Суммирование числовых рядов. Вычислить сумму ряда, состоящего из N слагаемых, и вывести результат с M знаками после запятой. Предложить набор из 5 тестовых заданий для проверки правильности вычислений. Вычислить: S=1/(x)^2 + 2/(x)^3 + 3/(x)^4 + 4/(x)^5 + 5/(x)^5 + 8/(x)^6 + ...; (N слагаемых)???решите пожалуйста! http://www.cyberforum.ru/cpp-beginners/thread69443.html
Описать функцию C++
Используя указатели,описать функцию,подсчитывающую количество отрицательных элементов в одномерном массиве. Привети пример вызова функции.(С++). Заранее спасибо:)
Таблица C++
Всем доброго времени суток. Помогите пожалуйста решить такую задачу: Есть таблица которая заполняется случайными данными в которой могут быть пустые ячейки (т.е. таблица строится по столбцам) например: 1 2 3 4 5 6 7 8 9 10 11 0 12 13 0 0 0 14 15 0
C++ Динамическое выделение памяти http://www.cyberforum.ru/cpp-beginners/thread69369.html
Имеется такая вот задача ! Нужно сделать что бы память выделялась динамически,а не на этапе компиляции!!! Какие будут предложения ??? #include <iostream> #include <stdlib.h> #include <time.h> using namespace std; const int SZ = 5; class Dice{
C++ Перегрузка операций в классе! Очень нужно! Перегрузить для класса stroka в теле класса Вычитание строк S1-S1: Из первого слова удалять только соответствующие вхождения буквы второго слова, например: олово – соло = во. Класс stroka: // stroka.cpp #include <iostream.h> #include <string.h> struct stroka{ char *ch; int len; public: подробнее

Показать сообщение отдельно
Funky108
2 / 2 / 0
Регистрация: 13.11.2009
Сообщений: 24
28.12.2009, 20:43  [ТС]
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
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include <conio.h>
 
/* results returned by input() / inputString() functions */
#define INPUT_FAIL 0
#define INPUT_SUCCESS 1
#define INPUT_CANCEL  2
 
/* width of screen in characters */
#define SCREEN_WIDTH 80
 
/* boolean return values */
#define TRUE 1
#define FALSE 0
 
/* 'Enter' character code */
#define ENTER  13
 
/* 'Escape' character code */
#define ESCAPE 27
 
/*global variables */
/* string of separators */
char *separators  = NULL;
/* string with key sequence */
char *key = NULL;
/* current input string */
char *string = NULL;
/* contains all input strings */
char **all_strings = NULL;
/* contains all words in the current string */
char **all_words = NULL;
 
/*  Function declarations in alphabet order */
char* addWord(int wordIndex, char *w, int length);
int   cancelInput(char* word);
void  freeMemoryPp(char** pp);
void  freeMemoryP(char* p);
void  input(char* str);
char* inputString(int* res);
int   isSeparator(char ch);
char* memReAlloc(char* mem, int size);
void  terminateProgram(char* s, int status);
 
 
int main (void)
{
    int stringIndex=0, k=0;
    int inputResult = 0;
 
    clrscr();
 
    for (k=0; k<SCREEN_WIDTH; k++) printf("*");
    printf("Input separators:                         <Esc> - exit from programm\n");
    for (k=0; k<SCREEN_WIDTH; k++) printf("*");
 
    input(separators);
 
    for (k=0; k<SCREEN_WIDTH; k++) printf("*");
    printf("Input text on English language:           <Esc> - exit from programm\n");
    for (k=0; k<SCREEN_WIDTH; k++) printf("*");
 
    do
    {
        string = inputString(&inputResult);
        all_strings = (char**)realloc(all_strings, (stringIndex+2) * sizeof(char*));
        if (all_strings == NULL)
        {
            terminateProgram("[main] Error: can not reallocate memory.", EXIT_FAILURE);
        }
        all_strings[stringIndex++] = string;
 
    } while(inputResult != INPUT_CANCEL);
 
    all_strings[stringIndex] = NULL;
 
    for (k=0;k<SCREEN_WIDTH;k++) printf("*");
    printf("Input key :                               <Esc> - exit from programm\n");
    for (k=0;k<SCREEN_WIDTH;k++) printf("*");
 
    input(key);
 
    for(k=0; all_strings[k] != NULL; k++)
    {
        printf("\nstring#%d = %s", k, all_strings[k]);
    }
 
    terminateProgram(NULL, EXIT_SUCCESS);
    return(EXIT_SUCCESS);
}
 
 
 
/*
 * Function to input 'separator' and 'key' strings
 * str - pointer to memory where string will be stored
 */
void input(char* str)
{
    /* current input character */
    char ch = 0;
    /* index of the current input character*/
    int index = 0;
 
 
    do {
        printf("Enter some ch\n");
        /* input the next character */
        ch = getch();
        printf("ch = %d, %c\n", ch, ch);
        if (ch == ENTER)
        {
            /* 'Enter' is a character to terminate input of the string */
            break;
        }
        if (ch == ESCAPE)
        {
            terminateProgram(NULL, EXIT_SUCCESS);
        }
 
        /* Reallocate memory to store next character:
           index+2 because: 1 character for just entered character and
                            1 character for terminating '\0' */
        memReAlloc(str, index+2);
        /* store character in the memory */
        str[index++] = ch;
    } while (TRUE);
 
    /* add terminating '\0' to the end of string */
    str[index] = '\0';
    return;
}
 
 
 
/*
 * Function which release allocated memory
 * s - string with message to show on the screen
 * status - exit status of the programm
 */
void terminateProgram(char* s, int status)
{
     /* free all allocated memory*/
    freeMemoryPp(all_words);
    freeMemoryPp(all_strings);
    freeMemoryP(string);
    freeMemoryP(separators);
    freeMemoryP(key);
 
    /* show the message on the screen */
    if (s != NULL)
    {
        puts(s);
    }
 
    /*wait for user input */
    puts("\nPlease enter any key to exit");
    getch();
 
    /*terminate the programm with specified status*/
    exit(status);
    return;
}
 
 
/*
 * Function to re-allocate memory
 * mem - pointer to memory to reallocate
 * size - new size of allocated memory
 */
char* memReAlloc(char* mem, int size)
{
    mem = (char*)realloc(mem, size * sizeof(char));
    if (mem == NULL)
    {
      terminateProgram("[memReAlloc] Error: can not reallocate memory.", EXIT_FAILURE);
    }
    return mem;
}
 
 
 
/*
 * Function returns:
 * TRUE  if character 'ch' is a separator
 * FALSE if character 'ch' is not a separator
 */
int isSeparator(char ch)
{
    if (strchr(separators, (int)ch) != NULL)
    {
        /* character 'ch' contained in the separators string */
        return TRUE;
    }
 
    /* character 'ch' is not a separator */
    return FALSE;
}
 
/*
 * Function to input one string of text which will be processed later
 * res - output parameter. Should be :
 * INPUT_SUCCESS - string entered
 * INPUT_CANCEL - cancel input of strings
 * returns pointer on entered string
 */
char* inputString(int* res)
{
    /* current input character */
    char ch;
    /* index of the current input character */
    int index = 0;
    /* latest word in the string */
    char* word;
    /* word start position */
    int wordStart = 0;
    /* word end position */
    int wordEnd = 0;
    /* index of words in the string */
    int wordIndex = 0;
    /* */
    char* str = NULL;
    /* result of function */
    *res = INPUT_SUCCESS;
 
    do
    {
        /* input the next character */
        ch = getch();
        printf("ch = %d, %c\n", ch, ch);
 
        if (ch == ENTER)
        {
            /* 'Enter' is a character to terminate input of the string */
            if (index != 0)
            {
                /* <Enter> is a end of word too */
                wordEnd = index-1;
                /* add latest word to the array and get it for analysis */
                printf("wordIndex = %d\n", wordIndex);
                printf("wordStart = %d\n", wordStart);
                printf("wordEnd = %d\n", wordEnd);
 
                word = addWord(wordIndex, str+wordStart, (wordEnd-wordStart)+1);
                /* is there the same word in the reverse order? */
                if (cancelInput(word) == TRUE)
                {
                    /* cancel text input */
                    *res = INPUT_CANCEL;
                }
            }
            break;
        }
 
        if (ch == ESCAPE)
        {
            terminateProgram(NULL, EXIT_SUCCESS);
        }
 
        /* Reallocate memory to store next character:
           index+2 because: 1 character for just entered character and
                            1 character for terminating '\0' */
        str = memReAlloc(str, index+2);
        /* store just entered character in the memory */
        str[index] = ch;
 
        /* start analysis from second character */
        if (index > 0)
        {
            if (!isSeparator(str[index-1]) && isSeparator(str[index]))
            {
                /* <NOT SEPARATOR> then <SEPARATOR> - end of the word */
                /* update wordEnd position */
                wordEnd = index-1;
                /* add latest word to the array and get it for analysis */
                printf("wordIndex = %d\n", wordIndex);
                printf("wordStart = %d\n", wordStart);
                printf("wordEnd = %d\n", wordEnd);
 
                word = addWord(wordIndex, str+wordStart, (wordEnd-wordStart)+1);
                /* is there the same word in the reverse order? */
                if (cancelInput(word) == TRUE)
                {
                    /* cancel text input */
                    *res = INPUT_CANCEL;
                    break;
                }
                wordIndex++;
            }
            else if(isSeparator(str[index-1]) && !isSeparator(str[index]))
            {
                /* <SEPARATOR> then <NOT SEPARATOR> - start of the word */
                wordStart = index;
            }
        }
        /* update character position */
        index++;
    } while (TRUE);
 
    /* add terminating '\0' to the end of string */
    str[index] = '\0';
    /* free memory allocated during processing of the current string */
    freeMemoryPp(all_words);
    return str;
}
 
/*
 * Function to free allocated memory
 * pp - pointer to pointer to allocated memory
 * **pp ---> *pp[0] ---> string0
 *           *pp[1] ---> string1
 *           *pp[2] ---> string2
 *           ....
 *           *pp[n] ---> NULL
 *
 * For example,
 * all_words ---> all_word[0] ---> word0
 *                all_word[1] ---> word1
 *                all_word[2] ---> word2
 *                ....
 *                all_word[n] ---> NULL
 */
void freeMemoryPp(char** pp)
{
    if (pp != NULL)
    {
        for(int i = 0; pp[i] != NULL; i++)
        {
            /* free memory pointed by *pp[n] level */
            if(pp[i] != NULL)
            {
                free(pp[i]);
                pp[i] = NULL;
            }
        }
        /* free **pp level */
        free(pp);
        pp = NULL;
    }
}
 
 
/*
 * Function to free allocated memory
 * p - pointer to allocated memory
 * *p ---> string
 *
 * For example,
 * *separators ---> separators_sequence
 */
void freeMemoryP(char* p)
{
    if (p != NULL)
    {
        /* free *p level */
        free(p);
        p = NULL;
    }
}
 
/*
 * Add specified word into 'all_words' array
 * wordIndex - index of the added word
 * w - added word
 * length - length of the word
 */
char* addWord(int wordIndex, char *w, int length)
{
    int i = 0;
    printf("wordIndex = %d", wordIndex);
    printf("length = %d", length);
 
    if (wordIndex == 0)
    {
        /* 2 = 1 - for word +
               1 - for terminating NULL */
        all_words =(char**)malloc(2 * sizeof(char*));
    }
    else
    {
        /* wordIndex+1 - include space for terminating NULL */
        all_words = (char**)realloc(all_words, (wordIndex+1) * sizeof(char*));
    }
    /* allocate memory for specified word + terminating '\0' */
    all_words[wordIndex] = (char*)malloc(length+1);
    /* zero and add terminating '\0'*/
    memset(all_words[wordIndex], 0, length+1);
    /* copy specified word into allocated memory */
    strncpy(all_words[wordIndex], w, length);
    /* end of all_words array */
    all_words[wordIndex+1] = NULL;
    printf("found word: %s", all_words[wordIndex]);
    for(i=0; all_words[i] != NULL; i++)
    {
        printf("\nword#%d = %s", i, all_words[i]);
    }
    return all_words[wordIndex];
}
 
/*
 * Function returns TRUE if specified 'word' in the reverse order
 * already exist in the current string
 * Otherwise returns FALSE
 */
int cancelInput(char* word)
{
    int i = 0;
    /*length of specified word */
    int wordLength = strlen(word);
    /* reverse index : from (wordLength - 1) to 0*/
    int j = wordLength - 1;
    /* allocate memory for reverse word */
    char* reverseWord = (char*)malloc(wordLength+1);
    if (reverseWord == NULL)
    {
      terminateProgram("[cancelInput] Error: can not allocate memory.", EXIT_FAILURE);
    }
 
    /* clear allocated memory */
    memset(reverseWord, 0, wordLength+1);
 
    /* reverse the specified word */
    for(i=0; i < wordLength; i++, j--)
    {
        reverseWord[i] = word[j];
    }
    /* check all words in the current string */
    for(i=0; all_words[i] != NULL; i++)
    {
        if ((strlen(all_words[i]) == strlen(reverseWord)) &&
            (strcmp(all_words[i], reverseWord) == 0) )
        {
            /* if reverse word and some word in the string are the same -
               cancel input of strings */
            free(reverseWord);
            return TRUE;
        }
    }
    /* there are no identical word to the specified reverce word */
    free(reverseWord);
    return FALSE;
}
Добавлено через 39 секунд
Вот еще код с ошибкой но что то уже близко.
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru