Які загальні невизначені форми поведінки, про які повинен знати програміст на C ++? [зачинено]

Які загальні невизначені форми поведінки, про які повинен знати програміст на C ++?

Скажіть, як:

a[i] = i++;

Покажчик

• Перенаправлення NULLпокажчика
• Перенаправлення покажчика, що повертається "новим" виділенням розміру нуля
• Використання покажчиків на об’єкти, термін служби яких закінчився (наприклад, стек виділених об'єктів або видалених об'єктів)
• Перенаправлення покажчика, який ще не був точно визначений
• Виконання арифметики вказівника, яка дає результат поза межами (або вище, або внизу) масиву.
• Перенаправлення вказівника на місце, розташоване поза кінцем масиву.
• Перетворення покажчиків на об’єкти несумісних типів
• Використовується memcpyдля копіювання буферів, що перекриваються .

Буфер переповнює

• Читання або запис об'єкту чи масиву з відхиленням, яке є негативним або перевищує розмір цього об'єкта (стек / купа переповнення)

Цілий перелив

• Переповнене ціле число переповнення
• Оцінка виразу, який математично не визначений
• Значення зсуву вліво на негативну суму (правильне зміщення на негативні суми визначено реалізацією)
• Зміщення значень на величину, що перевищує або дорівнює кількості бітів у кількості (наприклад, int64_t i = 1; i <<= 72не визначено)

Типи, ролі та загравання

• Закидання числового значення у значення, яке не може бути представлено цільовим типом (безпосередньо чи через static_cast)
• Використання автоматичної змінної до її визначеного призначення (наприклад, int i; i++; cout << i;)
• Використання значення будь-якого об'єкта типу, окрім volatileабо sig_atomic_tпри отриманні сигналу
• Спроба змінити літеральний рядок або будь-який інший об'єкт const протягом його життя
• Об’єднання вузького з широким літеральним рядком під час попередньої обробки

Функція та шаблон

• Не повертає значення з функції, що повертає значення (безпосередньо або шляхом витікання з пробного блоку)
• Кілька різних визначень для однієї сутності (клас, шаблон, перерахування, вбудована функція, статична функція члена тощо)
• Нескінченна рекурсія в інстанціюванні шаблонів
• Виклик функції за допомогою різних параметрів або прив'язки до параметрів і зв'язків, які функція визначається як використання.

ООП

• Каскадні руйнування об'єктів зі статичною тривалістю зберігання
• Результат віднесення об'єктів, що частково перекриваються
• Рекурсивно повторне введення функції під час ініціалізації її статичних об'єктів
• Здійснення віртуальних функцій викликає чисті віртуальні функції об'єкта від його конструктора чи деструктора
• Посилаючись на нестатичні члени об'єктів, які не були побудовані або вже зруйновані

Вихідний файл та попередня обробка

• Непорожній вихідний файл, який не закінчується новим рядком або закінчується зворотною косою рисою (до C ++ 11)
• Зворотний косий рядок з наступним символом, який не є частиною вказаних кодів евакуації в символьній або рядковій константі (це визначено реалізацією в C ++ 11).
• Перевищення меж реалізації (кількість вкладених блоків, кількість функцій у програмі, наявний простір стека ...)
• Числові значення препроцесора, які не можуть бути представлені символом a long int
• Директива щодо попередньої обробки ліворуч від визначення функції, що нагадує функцію
• Динамічно генеруючи визначений маркер у #ifвиразі

Для класифікації

• Виклик виходу під час знищення програми зі статичною тривалістю зберігання

Порядок оцінювання параметрів функції - це не визначена поведінка . (Це не призведе до збою, вибуху або замовлення піци ... На відміну від невизначеної поведінки .)

Єдина вимога - всі параметри повинні бути повністю оцінені до виклику функції.

Це:

// The simple obvious one.
callFunc(getA(),getB());

Це може бути рівнозначно цьому:

int a = getA();
int b = getB();
callFunc(a,b);

Або це:

int b = getB();
int a = getA();
callFunc(a,b);

Це може бути будь-який; це залежить від компілятора. Результат може мати значення, залежно від побічних ефектів.

Компілятор вільний повторно упорядкувати частини вираження (якщо вважати, що значення не змінюється).

З початкового питання:

a[i] = i++;

// This expression has three parts:
(a) a[i]
(b) i++
(c) Assign (b) to (a)

// (c) is guaranteed to happen after (a) and (b)
// But (a) and (b) can be done in either order.
// See n2521 Section 5.17
// (b) increments i but returns the original value.
// See n2521 Section 5.2.6
// Thus this expression can be written as:

int rhs  = i++;
int lhs& = a[i];
lhs = rhs;

// or
int lhs& = a[i];
int rhs  = i++;
lhs = rhs;

Подвійне перевірене блокування. І одна проста помилка зробити.

A* a = new A("plop");

// Looks simple enough.
// But this can be split into three parts.
(a) allocate Memory
(b) Call constructor
(c) Assign value to 'a'

// No problem here:
// The compiler is allowed to do this:
(a) allocate Memory
(c) Assign value to 'a'
(b) Call constructor.
// This is because the whole thing is between two sequence points.

// So what is the big deal.
// Simple Double checked lock. (I know there are many other problems with this).
if (a == null) // (Point B)
{
    Lock   lock(mutex);
    if (a == null)
    {
        a = new A("Plop");  // (Point A).
    }
}
a->doStuff();

// Think of this situation.
// Thread 1: Reaches point A. Executes (a)(c)
// Thread 1: Is about to do (b) and gets unscheduled.
// Thread 2: Reaches point B. It can now skip the if block
//           Remember (c) has been done thus 'a' is not NULL.
//           But the memory has not been initialized.
//           Thread 2 now executes doStuff() on an uninitialized variable.

// The solution to this problem is to move the assignment of 'a'
// To the other side of the sequence point.
if (a == null) // (Point B)
{
    Lock   lock(mutex);
    if (a == null)
    {
        A* tmp = new A("Plop");  // (Point A).
        a = tmp;
    }
}
a->doStuff();

// Of course there are still other problems because of C++ support for
// threads. But hopefully these are addresses in the next standard.

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

Призначення константи після зачистки constness, використовуючи const_cast<>:

const int i = 10; 
int *p =  const_cast<int*>( &i );
*p = 1234; //Undefined

Окрім невизначеної поведінки , існує також однаково неприємна поведінка, визначена реалізацією .

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

Поведінка, визначена реалізацією, - це дія програми, результат якої не визначений стандартом, але яку необхідно документувати. Приклад - "Багатобайтові літерали символів", із запитання про переповнення стека. Чи є компілятор C, який цього не зможе скомпілювати? .

Поведінка, визначена реалізацією, кусає вас лише коли ви починаєте перенесення (але оновлення до нової версії компілятора також переносить!)

Змінні можуть бути оновлені лише один раз у виразі (технічно один раз між точками послідовності).

int i =1;
i = ++i;

// Undefined. Assignment to 'i' twice in the same expression.

Основне розуміння різних екологічних меж. Повний список знаходиться в розділі 5.2.4.1 специфікації C. Ось кілька;

• 127 параметрів в одному визначенні функції
• 127 аргументів в одному виклику функції
• 127 параметрів в одному макрозначенні
• 127 аргументів в одному макро-виклику
• 4095 символів у логічному рядку джерела
• 4095 символів у рядку символів буквально або в широкому рядку (після конкатенації)
• 65535 байт в об'єкті (лише в розміщеному середовищі)
• 15 рівнів швидкості для # включено менше
• 1023 мітки регістру для оператора перемикача (виключаючи ті, що стосуються будь-яких операторів переключення)

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

Якщо ці межі перевищені, у вас є невизначена поведінка (збої, вади безпеки тощо).

Правильно, я знаю, це з специфікації C, але C ++ ділиться цими основними підтримками.

Використовується memcpyдля копіювання між областями пам'яті, що перекриваються. Наприклад:

char a[256] = {};
memcpy(a, a, sizeof(a));

Поведінка не визначена відповідно до Стандарту C, який поширюється на стандарт C ++ 03.

7.21.2.1 Функція memcpy

Конспект

1 / #include void * memcpy (void * обмежити s1, const void * обмежити s2, size_t n);

Опис

2 / Функція memcpy копіює n символів з об'єкта, на який вказує s2, в об'єкт, на який вказує s1. Якщо копіювання відбувається між об'єктами, які перекриваються, поведінка не визначена. Повертає 3 Функція memcpy повертає значення s1.

7.21.2.2 Функція пам'яті

Конспект

1 #include void * memmove (void * s1, const void * s2, size_t n);

Опис

2 Функція пам'яті копіює n символів з об'єкта, на який вказує s2, в об'єкт, на який вказує s1. Копіювання відбувається так, ніби n символів з об’єкта, на які вказує s2, спочатку копіюються у тимчасовий масив з n символів, який не перекриває об'єкти, на які вказують s1 та s2, а потім n символів із тимчасового масиву копіюються в об’єкт, на який вказує s1. Повертається

3 Функція пам'яті повертає значення s1.

Єдиним типом, для якого С ++ гарантує розмір, є char. А розмір - 1. Розмір усіх інших типів залежить від платформи.

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