Есть ли разница в оптимизации между определением переменной до цикла

@andrewkop85 · Регистрация: 20.09.2018

Студворк — интернет-сервис помощи студентам

Подскажите, есть ли разница в производительности между

C++
1
2
3
4
5
6
7
8
9
int i;
while () {
    ....
    ....
    i = 0;
    while () {
          .....
    }
}

и

C++
1
2
3
4
5
6
7
8
while () {
    ....
    ....
    int i = 0;
    while () {
          .....
    }
}

Второй кусок кода с точки зрения принципа "где родился, там и пригодился" более лаконичный, но боюсь, что определение переменной отъедает доп процессорное время. Или нет?

@zss · 28.09.2018, 10:28

С чего Вы решили, что "отъедает"?

@andrewkop85 · 28.09.2018, 10:29 **[ТС]**

Так не решил же. Спрашиваю. Но сочту ваше сообщение за ответ по теме. Что лучше второй вариант. Ок?

@hoggy · 28.09.2018, 11:38

нет разницы для примитивных переменных

@Undisputed · 28.09.2018, 12:04

hoggy,

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
 
int count = 10;
 
int main()
{
    int sum = 0;
    int input;
    for (size_t i = 0; i < count; i++)
    {
        std::cin >> input;
        sum += input;
    }
    std::cout << sum << '\n';
}

ASM OUTPUT:

Assembler
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
main:
        push    rbp
        push    rbx
        sub     rsp, 24
        mov     ebp, DWORD PTR count[rip]
        test    ebp, ebp
        je      .L2
        xor     ebx, ebx
        xor     ebp, ebp
.L3:
        lea     rsi, [rsp+12]
        mov     edi, OFFSET FLAT:_ZSt3cin
        add     rbx, 1
        call    std::basic_istream<char, std::char_traits<char> >::operator>>(int&)
        movsx   rax, DWORD PTR count[rip]
        add     ebp, DWORD PTR [rsp+12]
        cmp     rax, rbx
        ja      .L3
.L2:
        mov     esi, ebp
        mov     edi, OFFSET FLAT:_ZSt4cout
        call    std::basic_ostream<char, std::char_traits<char> >::operator<<(int)
        lea     rsi, [rsp+11]
        mov     edx, 1
        mov     BYTE PTR [rsp+11], 10
        mov     rdi, rax
        call    std::basic_ostream<char, std::char_traits<char> >& std::__ostream_insert<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*, long)
        add     rsp, 24
        xor     eax, eax
        pop     rbx
        pop     rbp
        ret

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
 
int count = 10;
 
int main()
{
    int sum = 0;
    for (size_t i = 0; i < count; i++)
    {
        int input;
        std::cin >> input;
        sum += input;
    }
    std::cout << sum << '\n';
}

Assembler
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
main:
        push    r12
        push    rbp
        push    rbx
        sub     rsp, 16
        mov     ebp, DWORD PTR count[rip]
        lea     r12, [rsp+12]
        test    ebp, ebp
        je      .L2
        xor     ebx, ebx
        xor     ebp, ebp
        lea     r12, [rsp+12]
.L3:
        mov     rsi, r12
        mov     edi, OFFSET FLAT:_ZSt3cin
        add     rbx, 1
        call    std::basic_istream<char, std::char_traits<char> >::operator>>(int&)
        movsx   rax, DWORD PTR count[rip]
        add     ebp, DWORD PTR [rsp+12]
        cmp     rax, rbx
        ja      .L3
.L2:
        mov     esi, ebp
        mov     edi, OFFSET FLAT:_ZSt4cout
        call    std::basic_ostream<char, std::char_traits<char> >::operator<<(int)
        mov     rsi, r12
        mov     edx, 1
        mov     BYTE PTR [rsp+12], 10
        mov     rdi, rax
        call    std::basic_ostream<char, std::char_traits<char> >& std::__ostream_insert<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*, long)
        add     rsp, 16
        xor     eax, eax
        pop     rbx
        pop     rbp
        pop     r12
        ret

x86-64 GCC 8.2 -O3

А говорите разницы нет

@Kastaneda · 28.09.2018, 12:38

Undisputed, так что мы в итоге наблюдаем? Как лучше/быстрее?

@Undisputed · 28.09.2018, 12:57

Kastaneda,
Вариант когда input за пределами цикла на моих тестах оказался быстрее. Можете проверить и у себя на всякий

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
#include <iostream>
#include <chrono>
 
int count = 10;
 
decltype(auto) inputIsNotInLoop()
{
    auto start = std::chrono::steady_clock::now();
    int sum = 0;
    int input;
    for (size_t i = 0; i < count; i++)
    {
        std::cin >> input;
        sum += input;
    }
    auto end = std::chrono::steady_clock::now();
    return end - start;
}
 
decltype(auto) inputIsInLoop()
{
    auto start = std::chrono::steady_clock::now();
    int sum = 0;
    for (size_t i = 0; i < count; i++)
    {
        int input;
        std::cin >> input;
        sum += input;
    }
    auto end = std::chrono::steady_clock::now();
    return end - start;
}
 
int main()
{
    if (inputIsNotInLoop() < inputIsInLoop()) {
        std::cout << "inputIsNotInLoop() fast than inputIsInLoop()\n";
    } else {
        std::cout << "equals or inputIsInLoop() fast than inputIsNotInLoop()\n";
    }
}

@hoggy · 28.09.2018, 12:57

Сообщение от Undisputed

А говорите разницы нет

ну и в чем разница?
с точки зрения эффективности?

@Kastaneda · 28.09.2018, 13:02

Сообщение от Undisputed

Вариант когда input за пределами цикла на моих тестах оказался быстрее

Зачем ты замерял время работы оператора ввода? мы же не про это говорим. А по ассемблерным листингам не понятно что бдует быстрее?

@hoggy · 28.09.2018, 13:02

Сообщение от Undisputed

на моих тестах оказался быстрее.

вас кто так тесты учил писать?
вы шум на микросхемах что ли измеряете?

http://rextester.com/ZUCVW95092

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
#include <iostream>
#include <chrono>
 
int count = 10;
 
decltype(auto) inputIsNotInLoop()
{
    auto start = std::chrono::steady_clock::now();
    int sum = 0;
    int input;
    for (size_t i = 0; i < count; i++)
    {
        std::cin >> input;
        sum += input;
    }
    auto end = std::chrono::steady_clock::now();
    return end - start;
}
 
decltype(auto) inputIsInLoop()
{
    auto start = std::chrono::steady_clock::now();
    int sum = 0;
    for (size_t i = 0; i < count; i++)
    {
        int input;
        std::cin >> input;
        sum += input;
    }
    auto end = std::chrono::steady_clock::now();
    return end - start;
}
 
int main()
{
    // поменяем местами очередность запусков
    // и о чудо! показания изменились
 
    if (inputIsInLoop() > inputIsNotInLoop() ) {
        std::cout << "inputIsNotInLoop() fast than inputIsInLoop()\n";
    } else {
        std::cout << "equals or inputIsInLoop() fast than inputIsNotInLoop()\n";
    }
    
    
    if (inputIsNotInLoop() < inputIsInLoop()) {
        std::cout << "inputIsNotInLoop() fast than inputIsInLoop()\n";
    } else {
        std::cout << "equals or inputIsInLoop() fast than inputIsNotInLoop()\n";
    }
}

output:
equals or inputIsInLoop() fast than inputIsNotInLoop()
inputIsNotInLoop() fast than inputIsInLoop()

@Kastaneda · 28.09.2018, 13:03

Я надеюсь ты данные хотя бы не руками вводил?

@Undisputed · 28.09.2018, 13:12

И да у меня есть в коде небольшая ошибка (может бросать вориниги) т.к идет сравнение между signed int и size_t в цикле (сразу не заметил).
Но к сути это отношения не имеет...

Добавлено через 8 минут

Сообщение от hoggy

вас кто так тесты учил писать?

Использовал простой и рабочий способ. А как надо было и почему?
И зачем понадобилось менять местами и делать проверку дважды?
Одного достаточно же. Иначе есть вероятность неправильного результата ввиду того что некоторые данные уже окажутся в кэше.

Сообщение от Kastaneda

Зачем ты замерял время работы оператора ввода?

В примере был i/o, выкидывать его не стал

@COKPOWEHEU · 28.09.2018, 13:14

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include "h.h"
 
int main(){
  int count = 10;
  int sum = 0;
  #ifdef EXT
    int input;
  #endif
  for (size_t i = 0; i < count; i++){
    #ifndef EXT
      int input;
    #endif
    std::cin >> input;
    sum += input;
  }
  std::cout << sum << '\n';
}

Code
1
2
3
4
$ g++ main.c -gdwarf-2 -Os -DEXT && objdump a.out -S > ext.lss
$ g++ main.c -gdwarf-2 -Os -DINT && objdump a.out -S > int.lss
$ diff ext.lss int.lss
$

разницы нет

Code
1
2
3
4
$ g++ main.c -gdwarf-2 -O0 -DEXT && objdump a.out -S > ext.lss
$ g++ main.c -gdwarf-2 -O0 -DINT && objdump a.out -S > int.lss
$ diff ext.lss int.lss
$

разницы нет

Code
1
2
3
4
5
6
7
8
9
10
11
$ g++ main.c -gdwarf-2 -O1 -DEXT && objdump a.out -S > ext.lss
$ g++ main.c -gdwarf-2 -O1 -DINT && objdump a.out -S > int.lss
$ diff ext.lss int.lss 
172c172                                                                                  
<  958: c6 44 24 0b 0a          movb   $0xa,0xb(%rsp)                                    
---                                                                                      
>  958: c6 44 24 0c 0a          movb   $0xa,0xc(%rsp)                                    
179c179                                                                                  
<  95d: 48 8d 74 24 0b          lea    0xb(%rsp),%rsi                                    
---                                                                                      
>  95d: 48 8d 74 24 0c          lea    0xc(%rsp),%rsi

поменяли адрес переменной?

Code
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
$ g++ main.c -gdwarf-2 -O2 -DINT && objdump a.out -S > int.lss             
$ g++ main.c -gdwarf-2 -O2 -DEXT && objdump a.out -S > ext.lss             
$ diff ext.lss int.lss                                                     
68c68                                                                                    
<  814: 4c 8d 25 65 09 20 00    lea    0x200965(%rip),%r12        # 201180 <_ZSt3cin@@GLIBCXX_3.4>
---
>  814: 4c 8d 2d 65 09 20 00    lea    0x200965(%rip),%r13        # 201180 <_ZSt3cin@@GLIBCXX_3.4>
77c77
<  828: 4c 8d 6c 24 0c          lea    0xc(%rsp),%r13
---
>  828: 4c 8d 64 24 0c          lea    0xc(%rsp),%r12
80,81c80,81
<  830: 4c 89 ee                mov    %r13,%rsi
<  833: 4c 89 e7                mov    %r12,%rdi
---
>  830: 4c 89 e6                mov    %r12,%rsi
>  833: 4c 89 ef                mov    %r13,%rdi
99,103c99,103
<  853: 48 8d 74 24 0b          lea    0xb(%rsp),%rsi
<  858: ba 01 00 00 00          mov    $0x1,%edx
<  85d: 48 89 c7                mov    %rax,%rdi
<  860: c6 44 24 0b 0a          movb   $0xa,0xb(%rsp)
<  865: e8 66 ff ff ff          callq  7d0 <_ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l@plt>
---
>  853: 4c 89 e6                mov    %r12,%rsi
>  856: ba 01 00 00 00          mov    $0x1,%edx
>  85b: 48 89 c7                mov    %rax,%rdi
>  85e: c6 44 24 0c 0a          movb   $0xa,0xc(%rsp)
>  863: e8 68 ff ff ff          callq  7d0 <_ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l@plt>
105,113c105,114
<  86a: 48 83 c4 18             add    $0x18,%rsp
<  86e: 31 c0                   xor    %eax,%eax
<  870: 5b                      pop    %rbx
<  871: 5d                      pop    %rbp
<  872: 41 5c                   pop    %r12
<  874: 41 5d                   pop    %r13
<  876: c3                      retq   
<  877: 66 0f 1f 84 00 00 00    nopw   0x0(%rax,%rax,1)
<  87e: 00 00 
---
>  868: 48 83 c4 18             add    $0x18,%rsp
>  86c: 31 c0                   xor    %eax,%eax
>  86e: 5b                      pop    %rbx
>  86f: 5d                      pop    %rbp
>  870: 41 5c                   pop    %r12
>  872: 41 5d                   pop    %r13
>  874: c3                      retq   
>  875: 90                      nop
>  876: 66 2e 0f 1f 84 00 00    nopw   %cs:0x0(%rax,%rax,1)
>  87d: 00 00 00

зачем-то поменяли местами r12 и r13
по адресу 853 поменяли lea на mov, после чего весь код сдвинулся на 2 байта

Code
1
2
3
4
$ g++ main.c -gdwarf-2 -O3 -DINT && objdump a.out -S > int.lss 
$ g++ main.c -gdwarf-2 -O3 -DEXT && objdump a.out -S > ext.lss 
$ diff ext.lss int.lss
#то же что при -O2

Code
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
$ g++ main.c -gdwarf-2 -Ofast -DINT && objdump a.out -S > int.lss 
$ g++ main.c -gdwarf-2 -Ofast -DEXT && objdump a.out -S > ext.lss    
$ diff ext.lss int.lss
68c68
<  834: 4c 8d 25 45 09 20 00    lea    0x200945(%rip),%r12        # 201180 <_ZSt3cin@@GLIBCXX_3.4>
---
>  834: 4c 8d 2d 45 09 20 00    lea    0x200945(%rip),%r13        # 201180 <_ZSt3cin@@GLIBCXX_3.4>
77c77
<  848: 4c 8d 6c 24 0c          lea    0xc(%rsp),%r13
---
>  848: 4c 8d 64 24 0c          lea    0xc(%rsp),%r12
80,81c80,81
<  850: 4c 89 ee                mov    %r13,%rsi
<  853: 4c 89 e7                mov    %r12,%rdi
---
>  850: 4c 89 e6                mov    %r12,%rsi
>  853: 4c 89 ef                mov    %r13,%rdi
99,103c99,103
<  873: 48 8d 74 24 0b          lea    0xb(%rsp),%rsi
<  878: ba 01 00 00 00          mov    $0x1,%edx
<  87d: 48 89 c7                mov    %rax,%rdi
<  880: c6 44 24 0b 0a          movb   $0xa,0xb(%rsp)
<  885: e8 66 ff ff ff          callq  7f0 <_ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l@plt>
---
>  873: 4c 89 e6                mov    %r12,%rsi
>  876: ba 01 00 00 00          mov    $0x1,%edx
>  87b: 48 89 c7                mov    %rax,%rdi
>  87e: c6 44 24 0c 0a          movb   $0xa,0xc(%rsp)
>  883: e8 68 ff ff ff          callq  7f0 <_ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l@plt>
105,113c105,114
<  88a: 48 83 c4 18             add    $0x18,%rsp
<  88e: 31 c0                   xor    %eax,%eax
<  890: 5b                      pop    %rbx
<  891: 5d                      pop    %rbp
<  892: 41 5c                   pop    %r12
<  894: 41 5d                   pop    %r13
<  896: c3                      retq   
<  897: 66 0f 1f 84 00 00 00    nopw   0x0(%rax,%rax,1)
<  89e: 00 00 
---
>  888: 48 83 c4 18             add    $0x18,%rsp
>  88c: 31 c0                   xor    %eax,%eax
>  88e: 5b                      pop    %rbx
>  88f: 5d                      pop    %rbp
>  890: 41 5c                   pop    %r12
>  892: 41 5d                   pop    %r13
>  894: c3                      retq   
>  895: 90                      nop
>  896: 66 2e 0f 1f 84 00 00    nopw   %cs:0x0(%rax,%rax,1)
>  89d: 00 00 00

поменяли регистр r12 на r13
поменяли lea на mov, в результате код съехал на 2 байта и для выравнивания добавили nop.
----------------------
Таким образом, формально отличие есть, но слишком незначительное

@Kastaneda · 28.09.2018, 13:21

COKPOWEHEU, у тебя по сути такой же выхлоп, что у Undisputed выше

Сообщение от COKPOWEHEU

поменяли регистр r12 на r13
поменяли lea на mov, в результате код съехал на 2 байта и для выравнивания добавили nop.

ты "слона" не видишь) основная разница не в этом, она есть.

@Undisputed · 28.09.2018, 13:21

Kastaneda,
Вот еще вариант без ввода/вывода в тестах. Специально для тебя и даже без ворнингов и даже без глобальных переменных

Что бы не было придирок по поводу попадания в кэш )

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
#include <iostream>
#include <chrono>
 
 
 
decltype(auto) inputIsNotInLoop()
{
    auto start = std::chrono::steady_clock::now();
    int sum = 0;
    
    volatile size_t count = 10;
    int add = 20;
    
    for (size_t i = 0; i < count; i++)
    {
        sum += add;
    }
    auto end = std::chrono::steady_clock::now();
    return end - start;
}
 
decltype(auto) inputIsInLoop()
{
    auto start = std::chrono::steady_clock::now();
    int sum = 0;
    
    volatile size_t count = 10;
    
    for (size_t i = 0; i < count; i++)
    {
        int add = 20;
        sum += add;
    }
    auto end = std::chrono::steady_clock::now();
    return end - start;
}
 
int main()
{
    if (inputIsNotInLoop() < inputIsInLoop()) {
        std::cout << "inputIsNotInLoop() fast than inputIsInLoop()\n";
    } else {
        std::cout << "equals or inputIsInLoop() fast than inputIsNotInLoop()\n";
    }
}

@hoggy · 28.09.2018, 13:24

Сообщение от Undisputed

И зачем понадобилось менять местами и делать проверку дважды?
Одного достаточно же.

затем что бы вы увидели, что ваша проверка ничерта не стоит.
потом что:

Сообщение от Undisputed

есть вероятность неправильного результата ввиду того что некоторые данные уже окажутся в кэше.

ситуация, когда запустили первой фуу, и фуу оказалась быстрее,
запустили первой бар, и бар оказался быстрее,
это - ситуация, когда тест яйца выеденного не стоит.

тесты должны показывать стабильные результаты,
на которые можно и нужно закладываться.

@Kastaneda · 28.09.2018, 13:25

Сообщение от Undisputed

Что бы не было придирок по поводу попадания в кэш )

чего?

MrGluck · 28.09.2018, 13:29

Сообщение от Undisputed

fast than

faster же
Хотя на фоне примера теста, это мелочи.

@Kastaneda · 28.09.2018, 13:47

Сообщение от Undisputed

Вот еще вариант без ввода/вывода в тестах

Собери с -О3, посмотри в ассемблере циклы вообще остались? Мне кажется оптимизатор их выкинет, т.к. их результат не используется.

Добавлено через 17 минут
Можешь объяснить почему у тебя count объявляется как volatile?

@Undisputed · 28.09.2018, 14:09

hoggy,
Тестировать на rextester время выполнения не самый лучший вариант. Это сайт куда в момент ваших тестов могут обращаться 100500 пользователей и в зависимости от их количества нагрузка на процессор сильно может плавать, поэтому думаю и в ваших тестах не все так идеально.

Запустил у себя на компьютере тесты по отдельности.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
#include <chrono>
  
volatile size_t count = 10000000;
 
decltype(auto) test()
{
    auto start = std::chrono::steady_clock::now();
    int sum = 0;
    int add = 20;
    
    for (size_t i = 0; i < count; i++)
    {
        sum += add;
    }
    auto end = std::chrono::steady_clock::now();
    return end - start;
}
 
int main()
{
    std::cout << test().count() << '\n';
}

и такой же тест но что бы add был в цикле.
Результаты плавающие (время от времени побеждает тот или иной код). Но в тестах где переменная за пределами цикла
чаще оказывался быстрее.

Сообщение от Kastaneda

Можешь объяснить почему у тебя count объявляется как volatile?

По этой причине

Сообщение от Kastaneda

циклы вообще остались?

Что бы они именно остались

Новые блоги и статьи Все статьи Все блоги /
Access VikBal 11.12.2025 Помогите пожалуйста !! Как объединить 2 одинаковые БД Access с разными данными.	Новый ноутбук volvo 07.12.2025 Всем привет. По скидке в "черную пятницу" взял себе новый ноутбук Lenovo ThinkBook 16 G7 на Амазоне: Ryzen 5 7533HS 64 Gb DDR5 1Tb NVMe 16" Full HD Display Win11 Pro	Музыка, написанная Искусственным Интеллектом volvo 04.12.2025 Всем привет. Некоторое время назад меня заинтересовало, что уже умеет ИИ в плане написания музыки для песен, и, собственно, исполнения этих самых песен. Стихов у нас много, уже вышли 4 книги, еще 3. . .	От async/await к виртуальным потокам в Python IndentationError 23.11.2025 Армин Ронахер поставил под сомнение async/ await. Создатель Flask заявляет: цветные функции - провал, виртуальные потоки - решение. Не threading-динозавры, а новое поколение лёгких потоков. Откат?. . .	Поиск "дружественных имён" СОМ портов Argus19 22.11.2025 Поиск "дружественных имён" СОМ портов На странице: https:/ / norseev. ru/ 2018/ 01/ 04/ comportlist_windows/ нашёл схожую тему. Там приведён код на С++, который показывает только имена СОМ портов, типа,. . .
Сколько Государство потратило денег на меня, обеспечивая инсулином. Programma_Boinc 20.11.2025 Сколько Государство потратило денег на меня, обеспечивая инсулином. Вот решила сделать интересный приблизительный подсчет, сколько государство потратило на меня денег на покупку инсулинов. . . .	Ломающие изменения в C#.NStar Alpha Etyuhibosecyu 20.11.2025 Уже можно не только тестировать, но и пользоваться C#. NStar - писать оконные приложения, содержащие надписи, кнопки, текстовые поля и даже изображения, например, моя игра "Три в ряд" написана на этом. . .	Мысли в слух kumehtar 18.11.2025 Кстати, совсем недавно имел разговор на тему медитаций с людьми. И обнаружил, что они вообще не понимают что такое медитация и зачем она нужна. Самые базовые вещи. Для них это - когда просто люди. . .	Создание Single Page Application на фреймах krapotkin 16.11.2025 Статья исключительно для начинающих. Подходы оригинальностью не блещут. В век Веб все очень привыкли к дизайну Single-Page-Application . Быстренько разберем подход "на фреймах". Мы делаем одну. . .	Фото: Daniel Greenwood kumehtar 13.11.2025

@zss Модератор 13766 / 10960 / 6490 Регистрация: 18.12.2011 Сообщений: 29,234
	28.09.2018, 10:28
	С чего Вы решили, что "отъедает"? 0

@andrewkop85 2 / 1 / 1 Регистрация: 20.09.2018 Сообщений: 17
	28.09.2018, 10:29 [ТС]
	Так не решил же. Спрашиваю. Но сочту ваше сообщение за ответ по теме. Что лучше второй вариант. Ок? 0

@hoggy 8973 / 4319 / 960 Регистрация: 15.11.2014 Сообщений: 9,760
	28.09.2018, 11:38
	нет разницы для примитивных переменных 0

@Kastaneda 5232 / 3205 / 362 Регистрация: 12.12.2009 Сообщений: 8,143 Записей в блоге: 2
	28.09.2018, 12:38
	Undisputed, так что мы в итоге наблюдаем? Как лучше/быстрее? 1

@Kastaneda 5232 / 3205 / 362 Регистрация: 12.12.2009 Сообщений: 8,143 Записей в блоге: 2
	28.09.2018, 13:03
	Я надеюсь ты данные хотя бы не руками вводил? 0