Чи є якісь мінуси для передачі структур за значенням у C, а не передачі вказівника?

Чи є якісь мінуси для передачі структур за значенням у C, а не передачі вказівника?

Якщо структура є великою, очевидно, є виконуючий аспект копіювання безлічі даних, але для меншої структури вона в основному повинна бути такою ж, як передача декількох значень функції.

Це може бути навіть цікавіше, коли вони використовуються як повернені значення. C має лише одиничні значення повернення від функцій, але вам часто потрібно кілька. Таким простим рішенням є скласти їх у структуру та повернути це.

Чи є причини для цього чи проти?

Оскільки може бути не очевидно для всіх, про що я тут говорю, я наведу простий приклад.

Якщо ви програмуєте на C, ви рано чи пізно почнете писати функції, які виглядають приблизно так:

void examine_data(const char *ptr, size_t len)
{
    ...
}

char *p = ...;
size_t l = ...;
examine_data(p, l);

Це не проблема. Єдине питання полягає в тому, що ви повинні погодитись зі своїм колегою, в якому параметри порядку повинні бути, щоб ви використовували однаковий режим у всіх функціях.

Але що відбувається, коли ви хочете повернути той самий вид інформації? Зазвичай ви отримуєте щось подібне:

char *get_data(size_t *len);
{
    ...
    *len = ...datalen...;
    return ...data...;
}
size_t len;
char *p = get_data(&len);

Це прекрасно працює, але набагато проблематичніше. Повернене значення - це повернене значення, за винятком того, що в цій реалізації воно не є. Немає способу сказати з вищесказаного, що функції get_data заборонено дивитися на те, на що вказує len. І ніщо не змушує компілятора перевірити, чи значення насправді повертається через цей покажчик. Тож у наступному місяці, коли хтось інший модифікує код, не розуміючи його належним чином (тому що він не прочитав документацію?), Він розбивається, не помічаючи когось, або він починає вибиватися випадковим чином.

Отже, рішення, яке я пропоную, - це проста структура

struct blob { char *ptr; size_t len; }

Приклади можна переписати так:

void examine_data(const struct blob data)
{
    ... use data.tr and data.len ...
}

struct blob = { .ptr = ..., .len = ... };
examine_data(blob);

struct blob get_data(void);
{
    ...
    return (struct blob){ .ptr = ...data..., .len = ...len... };
}
struct blob data = get_data();

З якоїсь причини я думаю, що більшість людей інстинктивно змусили exam_data взяти покажчик на структурну крапку, але я не розумію, чому. Він все одно отримує вказівник і ціле число, просто набагато зрозуміліше, що вони йдуть разом. І у випадку get_data неможливо зіпсувати так, як я описав раніше, оскільки немає вхідного значення для довжини, і повинна бути повернута довжина.

Для невеликих конструкцій (наприклад, точки, прямої) передача за значенням цілком прийнятна. Але, окрім швидкості, є ще одна причина, чому ви повинні обережно пропускати / повертати великі структури за значенням: Складіть простір.

Багато програм програмування на С розроблено для вбудованих систем, де пам'ять переважає, а розмір стека може бути виміряний у КБ або навіть байтах ... Якщо ви передаєте або повертаєте структури за значенням, копії цих структур будуть розміщені на стек, потенційно спричиняючи ситуацію, що цей сайт названий на честь ...

Якщо я бачу додаток, який, здається, має надмірне використання стека, структури, передані за значенням, - це одна з речей, яку я шукаю першою.

Одна з причин не робити цього, про що не згадувалося, це те, що це може спричинити проблему, коли важлива бінарна сумісність.

Залежно від використовуваного компілятора, структури можуть передаватися через стек або регістри залежно від варіантів / реалізації компілятора

Дивіться: http://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html

-fpcc-struct-return

-freg-struct-return

Якщо два компілятори не згодні, речі можуть підірватися. Потрібно сказати, що основні причини цього не пояснюються - це споживання стека та продуктивність.

Щоб дійсно відповісти на це питання, потрібно заглибитися в землю складання:

(У наступному прикладі використовується gcc на x86_64. Будь-хто може додавати інші архітектури, такі як MSVC, ARM тощо).

Давайте маємо нашу прикладну програму:

// foo.c

typedef struct
{
    double x, y;
} point;

void give_two_doubles(double * x, double * y)
{
    *x = 1.0;
    *y = 2.0;
}

point give_point()
{
    point a = {1.0, 2.0};
    return a;
}

int main()
{
    return 0;
}

Скомпілюйте його з повними оптимізаціями

gcc -Wall -O3 foo.c -o foo

Подивіться на збірку:

objdump -d foo | vim -

Ось що ми отримуємо:

0000000000400480 <give_two_doubles>:
    400480: 48 ba 00 00 00 00 00    mov    $0x3ff0000000000000,%rdx
    400487: 00 f0 3f 
    40048a: 48 b8 00 00 00 00 00    mov    $0x4000000000000000,%rax
    400491: 00 00 40 
    400494: 48 89 17                mov    %rdx,(%rdi)
    400497: 48 89 06                mov    %rax,(%rsi)
    40049a: c3                      retq   
    40049b: 0f 1f 44 00 00          nopl   0x0(%rax,%rax,1)

00000000004004a0 <give_point>:
    4004a0: 66 0f 28 05 28 01 00    movapd 0x128(%rip),%xmm0
    4004a7: 00 
    4004a8: 66 0f 29 44 24 e8       movapd %xmm0,-0x18(%rsp)
    4004ae: f2 0f 10 05 12 01 00    movsd  0x112(%rip),%xmm0
    4004b5: 00 
    4004b6: f2 0f 10 4c 24 f0       movsd  -0x10(%rsp),%xmm1
    4004bc: c3                      retq   
    4004bd: 0f 1f 00                nopl   (%rax)

Виключаючи noplколодки, give_two_doubles()має 27 байт, тоді як give_point()має 29 байт. З іншого боку, give_point()дає одну меншу інструкцію, ніжgive_two_doubles()

Що цікаво, ми помічаємо, що компілятор зміг оптимізуватись movдо більш швидких варіантів SSE2 movapdта movsd. Крім того, give_two_doubles()насправді переміщуються дані з пам’яті і з неї, що робить все повільним.

Мабуть, велика частина цього може не застосовуватися у вбудованих середовищах (саме там ігрове поле для C є більшістю часу в наші дні). Я не майстер збірки, тому будь-які коментарі будуть вітатися!

Простим рішенням буде повернути код помилки як повернене значення, а все інше як параметр у функції.
Цей параметр може бути структурою курсу, але не бачити якоїсь особливої ​​переваги, передаючи це за значенням, тільки що надіслав покажчик.
Передача структури за значенням небезпечна, вам потрібно бути дуже обережним, що ви передаєте, пам’ятайте, що в C не існує конструктора копіювання, якщо один із параметрів структури є вказівником, значення вказівника буде скопійовано, це може бути дуже заплутано і важко підтримувати.

Просто для завершення відповіді (повний кредит для Родді ) використання стека - це ще одна причина не передати структуру за значенням, повірте мені, налагодження переповнення стека - це справжня PITA.

Відтворити до коментаря:

Передача структури за вказівником означає, що деяка сутність має право власності на цей об’єкт і має повне знання про те, що і коли слід випустити. Передаючи структуру за значенням, створюють приховані посилання на внутрішні дані структури (вказівники на іншу структуру тощо). Це важко підтримувати (можливо, але чому?).

Одне, про що люди тут забули згадати (або я це не помічав) - це те, що у конструкцій зазвичай є підкладка!

struct {
  short a;
  char b;
  short c;
  char d;
}

Кожен знак - 1 байт, кожен короткий - 2 байти. Наскільки велика структура? Ні, це не 6 байт. Принаймні, не на будь-яких більш часто використовуваних системах. У більшості систем це буде 8. Проблема полягає в тому, що вирівнювання не є постійним, воно залежить від системи, тому одна і та ж структура матиме різні вирівнювання та різні розміри для різних систем.

Мало того, що прокладка додатково з’їсть ваш стек, це ще й додасть непевності того, що ви не зможете заздалегідь передбачити прокладку, якщо ви не знаєте, як працює ваша системна колодка, а потім перегляньте кожну структуру, яку ви маєте у своєму додатку, та обчисліть розмір. для нього. Проходження вказівника займає передбачувану кількість місця - невизначеності немає. Розмір вказівника відомий системі, він завжди рівний, незалежно від того, як виглядає структура, а розміри вказівника завжди вибираються таким чином, щоб вони вирівнювалися і не потребували прокладки.

Я думаю, що ваше запитання досить добре підсумувало речі.

Ще однією перевагою передачі структур за значенням є те, що право власності на пам'ять явне. Не дивно, чи структура є з купи і хто несе відповідальність за її звільнення.

Я б сказав, що передача (не надто великої) структури за значенням як в якості параметрів, так і як зворотних значень - цілком законна методика. Звичайно, слід подбати про те, щоб структура була або типом POD, або семантика копії була чітко визначена.

Оновлення: Вибачте, у мене була надійна шапка на C ++. Я пригадую той час, коли повертати структуру з функції не було законно в C, але це, мабуть, змінилося відтоді. Я б все-таки сказав, що це дійсно до тих пір, поки всі компілятори, які ви очікуєте використовувати, підтримують цю практику.

Ось щось ніхто не згадував:

void examine_data(const char *c, size_t l)
{
    c[0] = 'l'; // compiler error
}

void examine_data(const struct blob blob)
{
    blob.ptr[0] = 'l'; // perfectly legal, quite likely to blow up at runtime
}

Члени а const structє const, але якщо цей член є вказівником (як char *), він стає char *constшвидше тим, що const char *ми справді хочемо. Звичайно, ми могли б припустити, щоconst це документація про наміри, і кожен, хто порушує це, пише поганий код (який вони є), але це недостатньо добре для деяких (особливо тих, хто щойно витратив чотири години на пошук причини крах).

Альтернативою може бути створення struct const_blob { const char *c; size_t l }та використання цього, але це досить безладно - це потрапляє в ту саму проблему схеми іменування, що і у мене з typedefing покажчиками. Таким чином, більшість людей дотримуються лише двох параметрів (або, більш імовірно, для цього випадку, використовуючи бібліотеку рядків).

Сторінка 150 Підручника зі складання ПК на веб-сайті http://www.drpaulcarter.com/pcasm/ має чітке пояснення про те, як C дозволяє функції повертати структуру:

C також дозволяє використовувати тип структури як повернене значення функції. Очевидно, що структура не може бути повернута в реєстр EAX. Різні компілятори вирішують цю ситуацію по-різному. Загальне рішення, яке використовують компілятори, - це внутрішньо переписати функцію як ту, яка приймає вказівник структури як параметр. Вказівник використовується для введення повернутого значення в структуру, визначену поза тим, що називається.

Я використовую такий код C для перевірки вищезазначеного твердження:

struct person {
    int no;
    int age;
};

struct person create() {
    struct person jingguo = { .no = 1, .age = 2};
    return jingguo;
}

int main(int argc, const char *argv[]) {
    struct person result;
    result = create();
    return 0;
}

Використовуйте "gcc -S" для створення збірки для цього фрагмента коду С:

    .file   "foo.c"
    .text
.globl create
    .type   create, @function
create:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $16, %esp
    movl    8(%ebp), %ecx
    movl    $1, -8(%ebp)
    movl    $2, -4(%ebp)
    movl    -8(%ebp), %eax
    movl    -4(%ebp), %edx
    movl    %eax, (%ecx)
    movl    %edx, 4(%ecx)
    movl    %ecx, %eax
    leave
    ret $4
    .size   create, .-create
.globl main
    .type   main, @function
main:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $20, %esp
    leal    -8(%ebp), %eax
    movl    %eax, (%esp)
    call    create
    subl    $4, %esp
    movl    $0, %eax
    leave
    ret
    .size   main, .-main
    .ident  "GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"
    .section    .note.GNU-stack,"",@progbits

Стек перед викликом створюють:

        +---------------------------+
ebp     | saved ebp                 |
        +---------------------------+
ebp-4   | age part of struct person | 
        +---------------------------+
ebp-8   | no part of struct person  |
        +---------------------------+        
ebp-12  |                           |
        +---------------------------+
ebp-16  |                           |
        +---------------------------+
ebp-20  | ebp-8 (address)           |
        +---------------------------+

Стек відразу після виклику create:

        +---------------------------+
        | ebp-8 (address)           |
        +---------------------------+
        | return address            |
        +---------------------------+
ebp,esp | saved ebp                 |
        +---------------------------+

Я просто хочу зазначити одну перевагу передачі ваших структур за значенням, що оптимізаційний компілятор може краще оптимізувати ваш код.