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

Поправте код - C++

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ классы непойму что с конструктором http://www.cyberforum.ru/cpp-beginners/thread88584.html
привет вот создал такой класс но чето конструктор ругается но что непойму( #include <iostream> #include <string> using namespace std; const int N = 30; class per { private:
C++ четырёхзначное число в чём ошибка написать программу являются ли все цифры четырёхзначного числа различнымию. при вводе числа делать проверку что введено четырёхзначное число. ввод вывод должен быть в цветном окне... http://www.cyberforum.ru/cpp-beginners/thread88580.html
C++ Строки.Си
Написать функцию, которая складывает одну строку с n символами другой строки не использовать strncat
Реализовать ввод, вывод и простейшие операции с матрицами C++
дана такая задача: Реализовать ввод, вывод и простейшие операции с матрицами (сложение, вычитание, умножение на число, умножение, транспонирование). Каждую операцию реализовать в виде функции....
C++ Могут ли значения быть сторонами треугольника? http://www.cyberforum.ru/cpp-beginners/thread88559.html
Есть задача: Напишите программу, которая читает три ненулевые значения типа double, определяет и печатает, могут ли они представлять стороны треугольника. А если они не равны нулю, то даже...
C++ 2 программы Здравствуйте Уважаемые! Если не сложно решите пожалуйста 2 задачки на Turbo c. 1)Дан двухмерный массив. Вставить в него строку из 100 чисел после строки с номером s. 2)Дан двухмерный массив.... подробнее

Показать сообщение отдельно
Johni
0 / 0 / 0
Регистрация: 02.12.2009
Сообщений: 21

Поправте код - C++

22.01.2010, 18:01. Просмотров 604. Ответов 7
Метки (Все метки)

Помогите поправить код,до работоспособности.....Оч нужно...

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
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Реализация :
// -----------------------------------------------------------------------------------------------
// Решения функций
//  > log2() (логарифм по основанию 2)
//  > cbrt() (кубический корень); мантисса ХХ бит, экспонента ХХ бит
// -----------------------------------------------------------------------------------------------
// Реализация :
// -----------------------------------------------------------------------------------------------
// Выводиться на экран выбор действия либо логарифм либо куб корень,вводиться вещественное число и
// выполняется выбранная операция.
// -----------------------------------------------------------------------------------------------
// Требования :
// -----------------------------------------------------------------------------------------------
// 1. Использование библиотеки Math.h запрещено.
// 2. Описать все функции самостоятельно.
// 3. Классы и структуры отвергаются.
// 4. Использовать циклы и условия.
// -----------------------------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <string>
#include <iostream>                                 // |Нужна для использования потокового ввода/вывода (I/O)
#include <conio>
#include <stdio>
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
int main(int argc, char *argv[])                    // |argc - кол-во переданных параметров консоли |*argv[] массив указателей на паметры консоли
{   
    double log2(double lNumber);                    // |Возвращает логарифм числа lNumber по основанию 2
double ipow(double lNumber, double lStep);      // |Возвращает результат возведение lNumber в степень nStep
double cbrt(double lNumber, short nStep = 3);   // |Возвращает корень кубический числа lNumber                                              // |Т.к. мы не используем эти параметры, их можно убрать . . . То есть, вместо этого написать "int main()"
    char szCmd[32] = "\0";
    system("title Algebra");                        // |Эта функция посылает команду в интерпретатор команд (cmd)
    
    std::cout << "// > log2(num)            -  logarithm  \'num\'. //\n";
    std::cout << "// > cbrt(num)            -  cube root  \'num\'. //\n";
    std::cout << "// > <Ctrl> + <C>     -  exiting . //\n";
    
enter:                                              // |Метка для оператора 'goto'
    memset(szCmd, '\0', sizeof(szCmd));             // |Установить все байты буфера 'szCmd' в нуль
    std::cout << "// > ";
    std::cin  >> szCmd;
 
    if(!strncmp(szCmd, "cbrt(", 5) || !strncmp(szCmd, "log2(", 5))                  // |Если первые 5 символов буфера 'szCmd' равны "cbrt(", то идем дальше
    {
        for(short nI = 5; nI < 32; nI++)            // |Выполнять тело for'a и увеличивать с каждым проходом на единицу переменную nI, пока nI меньше 32
        {
            if(szCmd[nI] == ')')                    // |Равна ли ячейка буфера под номером nI символу ')'. Если да, то продолжаем
            {
                if(nI == 5)                         // |Если символ ')' оказался по счету пятым в буфере, то это значит, что мы не передали функции 'cbrt' параметры
                {
                    std::cerr << "// > Command incorrect. See params of \'";
                    std::cerr << (strncmp(szCmd, "cbrt", 4) ? "log2" : "cbrt") << "(num)\'\n"; // |Сообщаем об ошибки . . .
                }
                else                                // |Если же ')' не пятый символ, то
                {
                    char szArg[32] = "\0";
                    strncpy_s(szArg, &szCmd[5], nI - 5); // |Копируем (nI - 5) символов начиная с 5-го символа буфера szCmd в буфер szArg
                    double nRes = (strncmp(szCmd, "cbrt", 4) ? log2(atof(szArg)) : cbrt(atof(szArg)));   // |atof(char*) - переводит строку в вещественное число (с дробъю) и возвращает это число
                    std::cout << (nRes > 0 ? "// > Result : " : "// > Command incorrect. See params : ") << nRes << "\n"; // |Если это число больше нуля, то показываем результат. Если меньше - выдаем ошибку
                    goto enter;                          // |Принудительно перейти к метке "enter" и начать выполнять программный код с следующей строки после метки "enter"
                }
            }
        }
        
        std::cerr << "// > Command incorrect. See symbol \')\'\n"; // |Если мы не нашли в буфере закрывающую скобку функции 'cbrt', то сообщаем об ошибке . . .
        goto enter;                                      // |Принудительно перейти к метке "enter" и начать выполнять программный код с следующей строки после метки "enter"
    }
 
    getchar();                                           // |Ждем ввода любого символа с клавиатуры (чтобы окно не исчезло само
    return false;                                        // |Завершаемся с кодом возврата 0 (false - это тоже самое, что и 0)
}
 
 
// Function 'cbrt'
///////////////////////////////////////////////////////////////////////////
// |lF      - степень, в которую будем возводить число lT
// |lT      - число, которое будет возводить в степень lF
// |nStep   - степень корня, который будет извлекаться из числа lNumber
///////////////////////////////////////////////////////////////////////////
 
double cbrt(double lNumber, short nStep)
{
    double lF = 0, lT = 0;
    while(lT < lNumber)                             // |Пока число возведенное в степень lF меньше lNumber выполняем тело цикла
    {
        lF += 0.001;                                // |Прибавляем к lF одну тысячную.
        lT = lF;                                    // |Присваиваем значение lT переменной lF
 
        for(short nI = 0; nI < nStep - 1; nI++)     // |Пока nI меньше nStep - 1 выполняем тело цикла и увеличиваем с каждым проходом nI на единицу
        {
            lT *= lF;                               // |Возводим в степень. То есть, умножаем значение lF само на себя nStep - 2 раза
        }
    }
 
    return lF;                                      // |Возвращаем полученный результат
}
 
// Function 'ipow'
///////////////////////////////////////////////////////////////////////////
// |lStep   - степень, в котору нужно возвести число lNumber
// |lResult - переменная, куда мы запишем результат
// |nNum    - целая часть показателя степени, в случае, если показатель дробный
///////////////////////////////////////////////////////////////////////////
 
double ipow(double lNumber, double lStep)
{
    long double lResult = 1;
    size_t nNum = (unsigned int)lStep;                  // |Сохраняем целую часть степени (lStep) в переменную nNum
 
    if((double)nNum == lStep)                           // |Если степень в которую нужно возвести не дробная, то выполняем тело
    {
        for(size_t nI = 0; nI < nNum; nI++)             // |Выполняем тело цикла nNum - 1 раз
        {
            lResult *= lNumber;                         // |Умножаем lNumber само на себя nNum раз
        }
    }
    else if((double)nNum < lStep)                       // |Или же, если степень в которую нужно возвести дробная, то выполняем тело этого блока
    {
        short nT = 1000;                                // |Записываем эквевалент знаменателя дроби степени в переменную nT
        double lD = lStep - (double)nNum;               // |Записываем в переменную lD дробную часть степени
        nNum *= nT;                                     // |Переводим целую часть степени в тысячные и сохраняем в переменную nNum
 
        for(double lI = 0; lI < lD; lI += 0.001)        // |Переводим дробную часть степени в эквевалент в целых числах (например 0.554 будет равно 554)
        {
            nNum++;
        }
 
        bool bFlg = true;                               // |Флаг, который указывает, сократили ли мы дробь стемели или нет
 
        for(size_t nJ = nT; nJ > 1; nJ--)               // |Выполняем тело цикла nT - 1 раз
        {
            for(size_t nM = 0; nM < 10 && bFlg; nM++)   // |Подбираем +/-10 к тому числу, которое нам надо сократить
            {
                if((((nNum - nM) % nJ == 0) || ((nNum + nM) % nJ == 0)) && (nT % nJ == 0))
                {
                    bFlg = false;                       // |Нам удалось сократить дробь
                    nNum /= nJ;                         // |Сокращаем nNum в nJ
                    nT /= nJ;                           // |Сокращаем nT в nJ
                }
            }
        }
 
        for(size_t nI = 0; nI < nNum; nI++)             // |Выполняем тело цикла nNum - 1 раз
        {
            lResult *= lNumber;                         // |lNumber в степень nNum
        }
 
        lResult = cbrt(lResult, nT);                    // |Извлекаем корень степени nT из lResult и записываем результат в lResult
    }
 
    return lResult;                                     // |Возвращаем результат
}
 
// Function 'log2'
///////////////////////////////////////////////////////////////////////////
// |lNumber - число, логарифм по основанию 2 которого нужно получить
// |lA      - степень, которую мы будем подбирать под основание 2
// |lR      - результат возведения 2 в подбираемую нами степень (lA)
///////////////////////////////////////////////////////////////////////////
 
double log2(double lNumber)
{
    double lA = cbrt(cbrt(lNumber)), lR = 0;        // |Записываем в lA начальное число степени, с которого начнем подбирать подходящую
 
    if(lNumber < 2.000)                             // |Если число, логарифм по основанию 2 которого нужно найти меньше 2.000, то результатом будет 1 (возвращаем 1)
    {
        return 1;
    }
                                                    // |Иначе
    while(lR < lNumber) {                           // |Если результат возведения 2 в степень lA меньше lNumber, выполняем тело цикла
        lR = ipow(2, lA);                           // |Записываем в lR 2 в степени lA
        lA += 0.001;                                // |Подбираем нужную нам степень увеличивая ее каждый проход цикла на одну тысячную
    }
 
    return lA - 0.001;                              // |Возвращаем результат (степень, если в которую возвести 2 получится lNumber) - 0.001
}
0
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru