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

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

Восстановить пароль Регистрация
 
Johni
0 / 0 / 0
Регистрация: 02.12.2009
Сообщений: 21
22.01.2010, 18:01     Поправте код #1
Помогите поправить код,до работоспособности.....Оч нужно...

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
}
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
qwarta
 Аватар для qwarta
56 / 56 / 5
Регистрация: 20.11.2009
Сообщений: 213
22.01.2010, 21:44     Поправте код #2
Строка 58: наверно нужно
C++
1
strncpy(szArg, &szCmd[5], nI - 5);
Строка 164: функция
C++
1
double cbrt(double lNumber, short nStep)
объявлена с двумя параметрами, а вызывается с одним
Johni
0 / 0 / 0
Регистрация: 02.12.2009
Сообщений: 21
22.01.2010, 22:15  [ТС]     Поправте код #3
А вообще можно в рабочий вид привести....Она компилируется хоть??У меня вообще не работает...ссылается что не определены переменные..

Добавлено через 15 минут
И возможноли вот этот кусок переписать как хранение чисел в массиве с помощью New и delete???без буфера....а с размерностью N для одного вещественного числа с максимальной длиной целой и дробной части XX разрядов

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
#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)
}
Добавлено через 13 минут
Помогите подправить мне сдавать через 4 часа....
qwarta
 Аватар для qwarta
56 / 56 / 5
Регистрация: 20.11.2009
Сообщений: 213
22.01.2010, 22:30     Поправте код #4
Во все три функции первым параметром передается double lNumber. А что это такое, где объявление? И какие еще переменные не определены?
Johni
0 / 0 / 0
Регистрация: 02.12.2009
Сообщений: 21
22.01.2010, 22:34  [ТС]     Поправте код #5
Переменные определены все.....

Добавлено через 2 минуты
тут скобок не хватает.....открытых....
qwarta
 Аватар для qwarta
56 / 56 / 5
Регистрация: 20.11.2009
Сообщений: 213
22.01.2010, 22:46     Поправте код #6
Ты же написал
У меня вообще не работает...ссылается что не определены переменные..
Johni
0 / 0 / 0
Регистрация: 02.12.2009
Сообщений: 21
22.01.2010, 22:49  [ТС]     Поправте код #7
Ну так переменные все есть....скобок не хватает....Хотя я ваще незнаю....я в программировании полный ноль.....
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
23.01.2010, 09:28     Поправте код
Еще ссылки по теме:

перевод десятичного вещественного в машинный код(двоичный код) C++
Перевести код программы Паскаля в код С++ C++
Нужно засунуть код инструкции в 4 char'a так, чтобы в памяти это был код инструкции. C++

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

Или воспользуйтесь поиском по форуму:
qwarta
 Аватар для qwarta
56 / 56 / 5
Регистрация: 20.11.2009
Сообщений: 213
23.01.2010, 09:28     Поправте код #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
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Составить программу решения функций log2() (логарифм по основанию 2) и cbrt(кубический корень);
// мантисса ХХ бит,экспонента ХХ бит,для вещественных чисел произвольной точности.
// Выводиться на экран выбор действия либо логарифм либо куб корень,вводиться вещественное число и
// выполняется выбранная операция.
// -----------------------------------------------------------------------------------------------
// Требования :
// -----------------------------------------------------------------------------------------------
// 1. Использование библиотеки Math.h запрещено.
// 2. Описать все функции самостоятельно.
// 3. Классы и структуры отвергаются.
// 4. Использовать циклы и условия.
// -----------------------------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <string>
#include <iostream> 
 
short nStep=3;
double lNumber;
double log2(double lNumber);                // |Возвращает логарифм числа lNumber по основанию 2
double ipow(double lNumber, double lStep);  // |Возвращает результат возведение lNumber в степень nStep
double cbrt(double lNumber);                // |Возвращает корень кубический числа lNumber 
 
int main(void)
{
    int action;
    do                                      // меню для работы
    {
      std::cout << "   Choose action\n";
      std::cout << "1. log2(num) -  logarithm  \'num\'.\n";
      std::cout << "2. cbrt(num) -  cube root  \'num\'.\n";
      std::cout << "3. Exiting.\n";
      std::cin  >> action;
      switch(action)
      {
        case 1:
             std::cout << " Enter the number -> ";
             std::cin  >> lNumber;
             std::cout <<log2(lNumber);
             break;
        case 2:
             std::cout << " Enter the number -> ";
             std::cin  >> lNumber;
             std::cout <<cbrt(lNumber);
             break;
        case 3:
             return 0;
      }
    }while(1);
}
    
    // Function 'cbrt'
///////////////////////////////////////////////////////////////////////////
// |lF          - степень, в которую будем возводить число lT
// |lT          - число, которое будет возводить в степень lF
// |nStep       - степень корня, который будет извлекаться из числа lNumber
///////////////////////////////////////////////////////////////////////////
 
double cbrt(double lNumber)
{
        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-0.001;         // |Возвращаем полученный результат
}
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 из lResult и записываем результат в lResult
        }
 
        return lResult;                     // |Возвращаем результат
}
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
}
Yandex
Объявления
23.01.2010, 09:28     Поправте код
Ответ Создать тему
Опции темы

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