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

С++ для начинающих

Войти
Регистрация
Восстановить пароль
 
Рейтинг: Рейтинг темы: голосов - 28, средняя оценка - 4.93
Myth
4 / 4 / 1
Регистрация: 17.03.2009
Сообщений: 13
#1

Cвязанные списки. Длинная арифметика. - C++

27.11.2009, 20:02. Просмотров 3404. Ответов 12
Метки нет (Все метки)

При помощи связанных списков необходимо написать процедуру возведения числа в большую степень (до 200 знаков)

как это реализовать?
можете написать алгоритм?
или сам код с описаниями, если не трудно?
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
27.11.2009, 20:02     Cвязанные списки. Длинная арифметика.
Посмотрите здесь:

C++ Длинная арифметика
C++ Длинная арифметика))
Длинная арифметика C++
C++ Длинная арифметика
Длинная арифметика C++
Длинная арифметика N+1 C++
Длинная арифметика C++
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
niXman
Эксперт C++
3134 / 1446 / 49
Регистрация: 09.08.2009
Сообщений: 3,441
Записей в блоге: 2
28.11.2009, 03:13     Cвязанные списки. Длинная арифметика. #2
Покажи что сделал.
Vladimir.
155 / 155 / 10
Регистрация: 24.11.2009
Сообщений: 375
28.11.2009, 11:47     Cвязанные списки. Длинная арифметика. #3
Разделим задачу на простейшие:

Очевидно, что при высоких степенях число будет очень длинным и расти оно будет очень быстро, соответсвенно перед нами стоит три задачи:
1. Хранение длинных чисел.
Вы предлагаете использовать связные списки (видимо препод так хочет), так что тут вариантов выбора не так много.
2. Возведение в степень.
Самым очевидным способом является понижение степени. Например, нужно возвести число в 1800-ю степень, для этого можно возвести его в 900-ю степень и умножить результат на себя. В свою очередь основание в 900-ой представимо как произведение двух оснований возведённых в 450-юстепень, и т.д...
3. Умножение длинных чисел.
Операция умножения длинных чисел весьма трудоемка, обычно её стараются оптимизировать. Возможно использование быстрых алгоритмов умножения(гуглим по запросу Карацуба, например). Но с другой стороны задача явно учебная, следовательно, код должен быть максимально прост и читабелен. Возможно использовать простые, интуитивно ясные алгоритмы, пусть даже в ущерб производительности и ресурсоёмкости. Вариант - возведение в степень реализуется циклом умножающим длинное число на основание нужное количество раз.

В котором из трёх пуктов необходима помощь?
Myth
4 / 4 / 1
Регистрация: 17.03.2009
Сообщений: 13
28.11.2009, 17:18  [ТС]     Cвязанные списки. Длинная арифметика. #4
niXman, пока только идеи! думаю над алгоритмом


Vladimir.,
1. как я понимаю, нужно разбить степень на группы по три-четыре элемента и заполнить ими поля связанного списка.
2. тоесть мы раскладываем аргумент на "простейшие" как это возможно, используя сложение степеней произведения одинаковых аргументов?
3. а потом перемножаем получившееся используя списки?
например: 3^1073 = 3^29*3^37
- заносим 3^29 и 3^37 в новые списки
- и умножаем
так?
Myth
4 / 4 / 1
Регистрация: 17.03.2009
Сообщений: 13
28.11.2009, 22:31  [ТС]     Cвязанные списки. Длинная арифметика. #5
ой! прошу прощения!
2. раскладываем степень через сумму
пример:
3^1073 = 3^1000*3^73
вот только дальше я не знаю что делать!
Vladimir.
155 / 155 / 10
Регистрация: 24.11.2009
Сообщений: 375
29.11.2009, 10:45     Cвязанные списки. Длинная арифметика. #6
Хорошо, разберёмся с алгоритмом. (Решаю задачу вместе с Вами, если покажется, что где-то ошибка - указывайте на неё)
Для начала давайте наложим следующие ограничения на задачу: пусть степень и число будут положительными целыми числами. Запятую и отрицительные основания будет добавить легко, отрицательные стрепени сложнее, но тоже можно.
Размышление вслух о представлении длинных чисел:
Тип unsigned long long int (далее ULLI) занимает 8 байт в памяти, следовательно в нём можно хранить числа меньшие 1,84*10^19. То есть 18 знаков без потери точности нам гарантированы. Все числа большие 18 знаков, будем называть большими. Именно для их хранения мы будем использовать список (кстати, это обязательное условие? массив был бы проще.). Таким образом мы будем использовать две системы счисления: с основаниями десять и ridex соответственно. ridex должен быть таким, чтобы все простые операции которые мы будем использовать не выкинули нас за максимальное значение ULLI. С удобным нам значением ridex определимся чуть позже, после того как будут известны операции.
Пример: Пусть наша степень р=13!=6227020800(dec) тогда, если ridex=1000, то:
p=13!= 800*ridex^0+20*ridex^1+227*ridex^2+6*ridex^3 = 6_227_20_800(ridex~)
Давайте сразу договоримся о следующем: в десятичной системе счисления запись идет от старшего разряда к младшему, в нашей системе счисления запись будет вестись от младшего к старшему. Так нам будет проще выполнять операции сложения и умножения, то есть:
13!=800_20_227_6
Пара примеров.

для начала сложение:
Код
  
13!      = 800_20_227_6
+13!     = 800_20_227_6
=13!+13! = 600_41_454_12 //800+800 = 1600, то есть 600  и 1 в старший разряд.
теперь умножение (в данном случае - в столбик, как в школе):
Код
13!       = 800_20_227_6
13!       = 800_20_227_6 
------------------------------------------
            0_656_600_981_4                  //*на 800(ridex)
            (0)_0_416_540_124                   //*на 20(ridex). Число в скобках - поправка на разряд.
            (0)_(0)_600_721_533_413_1      //*на 227(ridex)
            (0)_(0)_(0)_800_124_362_37    //*на 6(ridex)
-----------------------------------------------------
13!*13!=0_656_616_43_788_775_38(ridex)

Из вышеизложенного следует две вещи: во-первых, для операции сложения необходимо ridex*10<1,84*10^19, для умножения необходимо ridex^2<1,84*10^19; во-вторых, написаных "знаний" достаточно для возведения числа в степень до 18 знаков длинной...
Что делать, если степень больше 1,84*10^19 ??? Только после чашки кофе...
Vladimir.
155 / 155 / 10
Регистрация: 24.11.2009
Сообщений: 375
29.11.2009, 14:45     Cвязанные списки. Длинная арифметика. #7
поправка:
в прошлом посте строку
... пусть наша степень р=13!=6227020800(dec) тогда...
читать: пусть наше число р=13!=6227020800(dec) тогда...

Продолжаем.
В прошлом посте было сформулировано что такое длинные числа и каким образом можно умножать длинные числа, давайте разберёмся, что нам нужно, для возведения числа в степень N. Покурил, подумал - увы - в мой мозг ничего кроме последовательного понижения степени не пришло. То есть x^(2*n) = (x^n)*(x^n) и x^(2n+1) = (x^n)(x^n)*x. Недостаток метода в том, что для понижения степени на три знака потребуется выполнить примерно 10 операций умножения, если наша степень длинной в 200 знаков, то для того чтоб вычислить значение, нам потребуется выполнить около 700 подобных операций (вообще-то, O(log(N)) операций.)..
Ближе к коду: есть два пути реализации: первый потребует представления степени (или куска степени) в двоичной системе; второй потребует определить операции деления на два, декримента и проверки кратности для наших длинных чисел. Склоняюсь ко второму варианту.
Тогда в реализации будет что-то подобное:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class my_long{};
my_long power;
my_long a;
my_long b;
 
while(!(power.is_empty))
{
  if(power.multiplicity()) {power.division(); multiplication(my_long &a,my_long &a);}
  else {power.decrement(); multiplication(my_long &b,my_long &a);}
}
//power.decrement() it's  power = power-1;
//power.division() it's power = power/2;
//power.multiplicity() it's  (power%2==0)?true:false;
//multiplication(b, a) its b = b*a;
Теперь определим как это делается:
Самое простое - проверка кратности двум: если младший разряд кратен двум, то и всё число кратно двум.
оперция дикримента тоже проста: Нужно вычесть из младшего разряда 1. По условию, он не кратен двум, следовательно его значение не ноль, то есть либо 1 либо больше. В любом случае - никаких заимствований делать не нужно.
Деление на два:
Код
разряд = старший разряд;
остаток = 0;
пока (разряд!=NULL)
{
  перейти в разряд;
  если ((разряд.значение)%2 == 0) 
     {разряд.значение = (разряд.значение+остаток*ridex)/2; остаток = 0;}
  иначе 
     {разряд.значение = (разряд.значение+остаток*ridex-1)/2; остаток =1;}
   разряд = предыдущий разряд // а для младшего разряда предыдущим будет NULL
}
Для того чтоб последнее нормально работало ridex следует выбирать кратным двум. А чтоб облегчить себе процесс ввода-вывода лучше кратным 10.. Вообщем, используем:
#define RIDEX
Теперь мы обладаем достаточными "знаниями" для решения задачи.

Пара замечаний: при умножении мы будем двигаться от младшего разряда к старшему, следовательно головой списка должен являться младший разряд (именно поэтому рекомендовалась
запись от младшего к старшему - для естественного движения по списку.) При делении - от старшего к младшему. Если планируется использовать один класс для представления возводимого числа и степени, то для удобства логично использовать двусвязный список (хотя, при некотором изврещании, можно и односвязным обойтись, но зачем? Хотя 4 байта на узел сэкономим=))
И еще, помимо умножения в столбик существуют алгоритмы быстрого умножения, их использование начинает давать выигрыш при числах длиннее 250 знаков..

По алгоритму вроде всё. Или нет??
Myth
4 / 4 / 1
Регистрация: 17.03.2009
Сообщений: 13
30.11.2009, 01:30  [ТС]     Cвязанные списки. Длинная арифметика. #8
ААА!!! пойду разбираться!
спасибо большое!
odip
Эксперт С++
7153 / 3293 / 59
Регистрация: 17.06.2009
Сообщений: 14,164
30.11.2009, 17:41     Cвязанные списки. Длинная арифметика. #9
второй потребует определить операции деления на два, декримента и проверки кратности для наших длинных чисел.
Второй способ не отличается от первого
Vladimir.
155 / 155 / 10
Регистрация: 24.11.2009
Сообщений: 375
01.12.2009, 10:16     Cвязанные списки. Длинная арифметика. #10
odip,
ну, это смотря как посмотреть....

Myth,
рабочий код

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
//ЙА ПРОГРАММКО, ЙА предназначена для возведения числа в большую 
//(200 знаков и больше) степень. Вводимыми данными являются 
//основание и степень, результат работы: 
//число = основание^степень. Изначально работает без 
//потери точности. Для хранения длинных чисел 
//используются двусвязные списки.
//Для возведения в степень исользуется аналог алгоритма
//"быстрого возведения в степень" основан на равенствах
//x^(2*n) = (x^n)*(x^n) и x^(2n+1) = (x^n)(x^n)*x .
//Код работает только с положительными целыми числами.
 
#include <iostream>
using namespace std;
 
#define UT unsigned int
//Определяет тип полезных данных хранимых в узлах списка.
//Рекомендуемо: unsigned long int
#define RIDEX 10
//Определяет основание системы счисления используемой 
//для хранения чисел в списках. Число представляется в виде:
//p=13!= 800*ridex^0+20*ridex^1+227*ridex^2+6*ridex^3 
//р=13!= 800_20_227_6(ridex)
//head->node1(800)<->node2(20)<->node3(227)<->node4(6)<-tail
//СТРОГО: ridex^2 < 256^sizeof(UT)
//СТРОГО: ridex кратно двум.
//СТРОГО: ridex*10 < 256^sizeof(UT)
//Рекомендуемо: ridex кратно 10. Облегчит написание функций ввода-вывода.
 
class Nodes 
{
    public:
        UT digit;
        Nodes* next;
        Nodes* prior;    
};// Что тут не понятного? Описание узлов списка.
 
 
class Long_numbers 
{
    private:
        Nodes* head; 
        Nodes* tail;
        Nodes* active; 
        Nodes* marker;   
        void Create()
        {
            Nodes* tmp = new Nodes;
            head = tmp;
            tail = tmp;
            tmp->next = NULL;
            tmp->prior = NULL;
            active = head;
            tmp->digit=0;
            marker = NULL;
        }
        
        void add_node(UT value)
        {
            Nodes* tmp = new Nodes;
            tmp->digit = value;
            tail->next = tmp;
            tmp->next = NULL;
            tmp->prior = tail;
            tail = tmp;             
        }// Добавляет узел в хвост списка. Записывает в него value.
 
 
       //ниже:Заглушка для оработки ошибок внутри класса
       void error_gag(int e)
       {
            printf("Error in Long_numbers: ");
            switch (e)
            {
                case 1:
                    {
                        printf("going before Head!\n");
                        active=head;
                    }
                case 2:
                    {
                        printf("decrement error!\n");
                    }
                case 3:
                    {
                        printf("invalid value in set-function!\n");
                    }
                case 4:
                    {
                        printf("in division_two modulus is 1!\n");
                    }
                default:printf("something wrong!\n");
            }
        }//Заглушка для оработки ошибок внутри класса        
 
 
    public:
        Long_numbers(){Create();}
        ~Long_numbers()
        {
            Nodes* tmp = head;
            while (tmp!=NULL)
            {
                head = tmp->next;
                delete tmp;
                tmp = head;
            }
        }
 
//Навигация по списку:
        void go_lowest(){active = head;}//Переход в наименьший разряд.
        bool its_lowest(){return (active->prior==NULL)?true:false;}
        void go_highest(){active=tail;}//Переход в наибольший разряд.
        bool its_highest(){return (active->next==NULL)?true:false;}
        void mark(){marker = active;}//Помечает текущий узел в списке.
        void go_mark(){active = marker;}//Переходит к помеченому узлу.
//функции работы с разрядами(узлами списка)
        UT get(){return (active->digit);}//Возвращает значение хранимое в разряде.        
 
        void go_high()
        {
            if (active->next==NULL)
                add_node(0);       
            active = active->next; 
        }//Переход в следующий разряд. Если узел не существует, то будет создан.
 
        void go_low()
        {
            if (active->prior!=NULL)
                active = active->prior;  
            else 
                error_gag(1);
        }//Переход в предыдущий разряд.
 
        void set(UT tmp)
        {            
            if ((tmp>=0)&&(tmp<RIDEX))
                active->digit = tmp;
            else error_gag(3);
        }//Устанавливает значение в разряд.
 
 
//Функции работы с числом.
        //ниже: Проверяет кратность х двум, если кратно, возвращает true 
        bool multiplicaty_two(){return (head->digit%2==0)?true:false;}
        //ниже: возарщает true, если большое число равно нулю.
        bool zerro(){ return (tail->digit==0)?true:false;}
 
        //ниже: Уменьшает х на единицу. Строго: младший разряд больше либо равен 1.
        void decrement()
        {
            if ( head->digit >= 1 )
                head->digit--;
            else
                error_gag(2);
        }
        
       
        //ниже: добавляет к текущему разряду число.( Исп: перенос в старший разряд)
        void add(UT carry)
        {
            Nodes* ip = active;
            while(true)
            {
                carry += ip->digit ;
                ip->digit = carry%RIDEX;
                carry -= ip->digit;
                carry /=RIDEX;
                if (carry==0) break;
                if (ip->next == NULL) add_node(0); //{ add_node(carry); break; }
                ip = ip->next;                            
            }
        }//Добавляет к текущему разряду число carry (строго меньшее ridex^2). 
        //В случае необходимости выполняет правку старших разрядов.
        
        //ниже: Производит деление на 2.Строго: число кратно 2.
        //пробегает список от хвоста к голове, деля значение разряда на два,
        //переносит остаток от деления в следующий разряд:
        void division_two()
        {
            UT carry = 0;//для переноса частного от деления.
            Nodes* ip = tail;//итерационный указатель.
            while(true)
            {
                if (ip->digit%2==0)
                {
                    ip->digit = (ip->digit+carry*RIDEX)/2;
                    carry=0;
                }
                else
                {
                    ip->digit = (ip->digit+carry*RIDEX-1)/2;
                    carry=1;
                }
                
                if(ip==head)
                {
                    if(carry) error_gag(4);//Error: modulus in lowest is one                    
                    break;
                }
                    
                ip = ip->prior;
                
  //             
            }
        //Старший разряд мог обратиться в ноль, если так, его нужно убрать:
        if(tail->digit == 0)
        {
            if (tail!=head)//чтоб не "убить" число 0 записаное в один узел.
            {
                tail = tail->prior;
                delete (tail->next);
                tail->next=NULL;           
            }
        }
                
        }//Производит деление на 2.Строго: число кратно 2.
 
        
};
 
 
 
//ниже: Умножает b на a и помещает результат в b.СТРОГО: &a!=&b
void multiplication(Long_numbers* b, Long_numbers* a);
void output(Long_numbers* x);//Выводит длинное число куда-нибудь(На экран?)
void input(Long_numbers* x);//Обеспечивает ввод длинного числа
void dig_copy(Long_numbers* x, Long_numbers* y);//Kопирует нижние разряды Х в У.
 
//========================
//====================
//===============
int main()
{   
    UT x = 0;
    Long_numbers power;
    Long_numbers number;
    Long_numbers tmp;//вспомогательный, для умножения а*а( tmp = a; a = a*tmp)
    Long_numbers t;//вспомогательный вектор.(для возведения в степень.)
    t.go_lowest();t.set(1); //t = 1
 
    system("cls");
    printf("IT's power");
    input(&power);
    printf("It's number");
    input(&number);
 
 
//Что вообще будет происходить. Если бы числа были "обычные", то код выглядел
//бы так:
//  long t=1;
//  while (power) 
//  {
//    if (power%2==0){ power/=2; number *= number; }
//    else { power-- ; t *= number; }
//  }
//  return t;
//Реализация для длинных чисел:(number*=number====>{tmp=number;number=number*tmp})
    while(!power.zerro())
    {
        if(power.multiplicaty_two())
        {
            power.division_two();
            dig_copy(&tmp, &number);//Всегда получаeтся, что number не короче tmp
            multiplication(&number,&tmp);
        }
        else
        {
            power.decrement();
            multiplication(&t,&number);
        }
    }
 
    system("cls");
 
    printf("\nSolution is done!!\n");   
    system("pause"); 
 
    output(&power);
    printf("\nit's power (must be one zerro)\n");
    system("pause");
 
    output(&t);
    printf("\nits number....\n");
    system("pause");
 
    return EXIT_SUCCESS;
}
 
 
//ниже: Умножение a на b с занесением результата в b.( b = b*a )СТРОГО: &a!=&b
void multiplication(Long_numbers* b, Long_numbers* a)
{
    if (a==b){printf("\n\t Fatal error. Press Ctrl+C.");system("PAUSE");}
    
    b->go_highest();
    UT tmp = 0;
    UT carry = 0;       //перенос в старший разряд
    while(true)
    {
        b->mark();
        tmp = b->get(); //Ибо текущее значение разряда Б измениться в первую очередь.
        b->set(0);      //И его нужно освободить.
        a->go_lowest();
        while(true)
        {
           // UT s = tmp*a->get(); //вспомогательная пременная
            b->add(tmp*(a->get()));
            if ((a->its_highest())) break;  
            a->go_high();
            b->go_high();       //Поправка на переход А в старший разряд.
        }
        b->go_mark();
        if (b->its_lowest()) break;
        b->go_low();
    }
 
} //Умножает a на b и заносит результат в b. Используется подредактированый алгоритм
// школьного умножения в столбик. Реализация: А поразрядно от меньшего к
//большему умножается на значение i-того разряда Б, результат прибавляется
//к разрядам Б старше i-того. Значения i перебираются от старшего Б до младшего.
// в результате, при полном прохождении, результат умножения А на Б оказывается 
//записаным в Б.Очевидно, А не должно совпадать с Б.PS:Количество вызовов и кода
//можно сократить раза в четыре, так что, если понятно что происходит, 
//рекомендуется оптимизировать.
 
 
//ниже: Kопирует нижние разряды y в x.
// то есть если Х=1 2 3, У = 4 5 6 7 и ridex=10, то dig_copy(&y,&x) даст У = 4 1 2 3,
// с другой стороны даст dig_copy(&x,&y) даст Х =4 5 6 7. Функция вспомогательная, 
//для возможности передачи multiplication двух одинаковых аргументов.
void dig_copy(Long_numbers* x, Long_numbers* y)
{
    x->go_lowest();
    y->go_lowest();
    while(true)
    {
        x->set(y->get());
        if(y->its_highest()) break;
        y->go_high();
        x->go_high();
    }
    if(!x->its_highest()) printf("\nwarning in dig_copy().");//совпадают не полностью
}//поразрядное копирование y в x.
 
void input(Long_numbers* x)//Написан для тестирования. ПЕРЕПИСАТЬ!!!!!
{   
    using namespace std; 
 //   system("cls");
    cout<<"\nInputing coef (num is sum coef(i)*ridex^i) from lowest to hhigest i\n";
    cout<<"end of inputing if coef = ridex\n";
    UT coef =0;
    x->go_lowest();
    cout<<"\nridex = "<<RIDEX<<"\tfirst coef is ";
    cin>>coef;
    x->set(coef);
    cout<<"\t\t\t\tfine!";
 
    do{
        cout<<"\nridex = "<<RIDEX<<"\tnext coef is ";
        cin>>coef;
        if ((coef>=0)&&(coef<RIDEX))
        {
            x->go_high();
            x->set(coef);
            cout<<"\t\t\t\tfine!";
        }
    }while(coef<RIDEX);
    cout<<"\n\t\t\t\tend of input!!\n\n\n";
    
}//Поразрядный ввод от младшего разряда к старшему. Прекращение ввода по заведомо
//неверному значению(нестрого-большее райдекс)
 
 
void output(Long_numbers* x)//написан для тестирования опереций.. Переписать!!!
{
    using namespace std; 
//    system("cls");
    cout<<"\nOutputing coef (num is sum coef(i)*ridex^i) from highest to lowest i\n";
    cout<<"ridex = "<<RIDEX<<endl;
    x->go_highest();
    while(!(x->its_lowest()))
    {
        cout<<x->get()<<endl;
        x->go_low();
    }
    cout<<x->get()<<endl<<"\t\t done!";
}// Вывод построчный от старшего разряда к младшему, 
// неявные нули в разрядах игнорируються.(002 выведет как 2)



Только RIDEX 100 - для проверки работоспособности... поставь побольше.
Система ввода вывода очень кривая..
Myth
4 / 4 / 1
Регистрация: 17.03.2009
Сообщений: 13
01.12.2009, 16:19  [ТС]     Cвязанные списки. Длинная арифметика. #11
Vladimir., а на каком это компиляторе?
я проверил на codeblocks'е и Borland C - выдаёт ошибочки!(
Vladimir.
155 / 155 / 10
Регистрация: 24.11.2009
Сообщений: 375
01.12.2009, 16:48     Cвязанные списки. Длинная арифметика. #12
какие именно?
вот только что в dev-c с дефолтными настройками засунул - скомпилилось. Это g++компиллер будет.
да и вообще в коде в принципе нет ничего такого на что компилятор влиять может..
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
02.12.2009, 02:39     Cвязанные списки. Длинная арифметика.
Еще ссылки по теме:

C++ Длинная арифметика
C++ Длинная арифметика
Длинная арифметика C++
Длинная арифметика C++
C++ Длинная арифметика

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

Или воспользуйтесь поиском по форуму:
accept
4817 / 3237 / 165
Регистрация: 10.12.2008
Сообщений: 10,682
02.12.2009, 02:39     Cвязанные списки. Длинная арифметика. #13
У тебя там printf, а в C++ нет int'а по-умолчанию
system("cls"), return EXIT_SUCCESS;

C++
1
2
#include <cstdio>
#include <cstdlib>
реакция на const t;

Код
[guest@station tmp]$ g++ -c t.cpp
t.cpp:2: ошибка: ISO C++ запрещает декларации ‘t’ без типа
t.cpp:2: ошибка: неинициализированная константа ‘t’
[guest@station tmp]$
Yandex
Объявления
02.12.2009, 02:39     Cвязанные списки. Длинная арифметика.
Ответ Создать тему
Опции темы

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