Что значит использована неинициализированная локальная переменная

1.6 – Неинициализированные переменные и неопределенное поведение

Неинициализированные переменные

В отличие от некоторых языков программирования, C/C++ не инициализирует большинство переменных автоматически заданным значением (например, нулем). Таким образом, когда компилятор выделяет переменной место в памяти, значением по умолчанию для этой переменной является любое (мусорное) значение, которое уже находится в этой области памяти! Переменная, которой не было присвоено известное значение (обычно посредством инициализации или присваивания), называется неинициализированной переменной.

Примечание автора

Многие читатели ожидают, что термины «инициализированный» и «неинициализированный» будут строго противоположными, но это не совсем так! Инициализация означает, что объекту было предоставлено начальное значение в точке определения. Неинициализированный означает, что объекту не было присвоено известное значение (каким-либо образом, включая присваивание). Следовательно, объект, который не инициализирован, но которому затем было присвоено значение, больше не является неинициализированным (потому что ему было присвоено известное значение).

• инициализация = объекту присваивается известное значение в точке определения;
• присваивание = объекту присваивается известное значение в точке, выходящей за рамки определения;
• неинициализированный = объекту еще не присвоено известное значение.

В качестве отступления.

Отсутствие инициализации является оптимизацией производительности, унаследованной от C, когда компьютеры были медленными. Представьте себе случай, когда вы собираетесь прочитать 100 000 значений из файла. В таком случае вы можете создать 100 000 переменных, а затем заполнить их данными из файла.

Если бы C++ инициализировал все эти переменные при создании значениями по умолчанию, это привело бы к 100 000 инициализаций (что было бы медленно) и к небольшой выгоде (поскольку вы всё равно перезапишете эти значения).

На данный момент вы всегда должны инициализировать свои переменные, потому что затраты на это ничтожны по сравнению с выгодой. Как только вы освоите язык, тогда могут быть определенные случаи, когда вы можете пропустить инициализацию в целях оптимизации. Но делать это всегда нужно выборочно и намеренно.

Использование значений неинициализированных переменных может привести к неожиданным результатам. Рассмотрим следующую короткую программу:

В этом случае компьютер выделит для x некоторую неиспользуемую память. Затем он отправит значение, находящееся в этой ячейке памяти, в std::cout , который напечатает значение (интерпретируемое как целое число). Но какое значение он напечатает? Ответ – «кто знает!», и ответ может (или не может) меняться каждый раз, когда вы запускаете программу. Когда автор запускал эту программу в Visual Studio, std::cout в первый раз вывел значение 7177728, а во второй раз – 5277592. Не стесняйтесь компилировать и запускать программу самостоятельно (ваш компьютер не взорвется).

В качестве отступления.

Некоторые компиляторы, такие как Visual Studio, при использовании конфигурации отладочной сборки будут инициализировать содержимое памяти некоторым предустановленным значением. Этого не произойдет при использовании конфигурации сборки выпуска. Поэтому, если вы хотите запустить указанную выше программу самостоятельно, убедитесь, что вы используете конфигурацию сборки выпуска (чтобы вспомнить, как это сделать, смотрите урок «0.9 – Настройка компилятора: конфигурации сборки»). Например, если вы запустите приведенную выше программу в конфигурации отладки в Visual Studio, она будет неизменно печатать -858993460 , потому что с помощью этого значения (интерпретируемого как целое число) Visual Studio инициализирует память в конфигурациях отладки.

Большинство современных компиляторов пытаются определить, используется ли переменная без присваивания значения. Если они смогут это обнаружить, они обычно выдадут ошибку времени компиляции. Например, компиляция приведенной выше программы в Visual Studio выдала следующее предупреждение:

Если ваш компилятор по этой причине не позволяет вам скомпилировать и запустить приведенную выше программу, вот возможное решение этой проблемы:

Использование неинициализированных переменных – одна из наиболее распространенных ошибок, которые совершают начинающие программисты, и, к сожалению, она также может быть одной из самых сложных для отладки (потому что программа всё равно может работать нормально, если неинициализированное значение было присвоено определенной области памяти, которая содержала приемлемое значение, например, 0).

Это основная причина использования оптимальной практики «всегда инициализировать переменные».

Неопределенное поведение

Использование значения из неинициализированной переменной – наш первый пример неопределенного поведения. Неопределенное поведение – это результат выполнения кода, поведение которого не определено языком C++. В этом случае в языке C++ нет правил, определяющих, что произойдет, если вы используете значение переменной, которой не было присвоено известное значение. Следовательно, если вы действительно сделаете это, результатом будет неопределенное поведение.

Код, реализующий неопределенное поведение, может проявлять любые из следующих симптомов:

• ваша программа при каждом запуске дает разные результаты;
• ваша программа постоянно дает один и тот же неверный результат;
• ваша программа ведет себя непоследовательно (иногда дает правильный результат, иногда нет);
• кажется, что ваша программа работает, но позже выдает неверные результаты;
• ваша программа вылетает сразу после запуска или позже;
• ваша программа работает с одними компиляторами, но не работает с другими;
• ваша программа работает до тех пор, пока вы не измените какой-нибудь другой, казалось бы, несвязанный код.

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

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

Правило

Старайтесь избегать всех ситуаций, которые приводят к неопределенному поведению, например, использование неинициализированных переменных.

Примечание автора

Один из наиболее распространенных типов комментариев, которые мы получаем от читателей, гласит: «Вы сказали, что я не могу делать X, но я всё равно сделал это, и моя программа работает! Почему?».

Есть два общих ответа. Наиболее распространенный ответ заключается в том, что ваша программа на самом деле демонстрирует неопределенное поведение, но это неопределенное поведение в любом случае дает желаемый результат… пока. Завтра (или на другом компиляторе или машине) этого может и не быть.

В качестве альтернативы, иногда авторы компиляторов допускают вольность к требованиям языка, когда эти требования могут быть более строгими, чем необходимо. Например, в стандарте может быть сказано: «Вы должны сделать X перед Y», но автор компилятора может счесть это ненужным и заставить Y работать, даже если вы сначала не выполните X. Это не должно влиять на работу правильно написанных программ, но в любом случае может привести к тому, что неправильно написанные программы будут работать. Таким образом, альтернативный ответ на вышеупомянутый вопрос заключается в том, что ваш компилятор может просто не следовать стандарту! Такое случается. Вы можете избежать этого, если отключили расширения компилятора, как описано в уроке «0.10 – Настройка компилятора: расширения компилятора».

Небольшой тест

Вопрос 1

Что такое неинициализированная переменная? Почему вам следует избегать их использования?

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

Вопрос 2

Что такое неопределенное поведение и что может произойти, если вы сделаете что-то, что демонстрирует неопределенное поведение?

Неопределенное поведение – это результат выполнения кода, поведение которого не определяется языком. Результатом может быть что угодно, в том числе и то, что ведет себя правильно.

Источник

Error C4700: использована неинициализированная локальная переменная

При компиляции выдаёт вот такие ошибки:
error C4700: использована неинициализированная локальная переменная «y»
error C4700: использована неинициализированная локальная переменная «x»

P.S Пробовал переставлять объявления и менял их, не помогает.

Error C4700: использована неинициализированная локальная переменная
Строка 52 #include «stdafx.h» #include «stdio.h» #include «iostream» #include «math.h».

Ошибка «error C4700: использована неинициализированная локальная переменная»
Здравствуйте! Есть задача: Дана вещественная матрица размерностью 8×8. Определить: 1) сумму.

Error C4700: использована неинициализированная локальная переменная «j»
Постоянно ругается на неинициализированную переменную на 23 строчке, хотя я инициализирую её во.

Решение

Переставить строку 31 и поставить ее после 38-й.

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

Добавлено через 3 минуты
С помощью этого не произойдет деление.

Yetty, Что вы предлагаете? Можете конкретно показать? Сразу оговорюсь если я использую std. не запускается, так что не делайте на это расчет.

З.Ы Visual Studio 2017

Добавлено через 36 секунд
palva, да, помогло.

Error C4700: использована неинициализированная локальная переменная «k»
Начал программировать в С++ недавно, решил набить программу по нахождению палиндрома, но когда.

Error C4700: использована неинициализированная локальная переменная «S». Что не так?
error C4700: использована неинициализированная локальная переменная «S» — Что не так ? подскажите.

Warning C4700: использована неинициализированная локальная переменная
1>c:\users\артем\documents\visual studio 2012\projects\consoleapplication37\source.cpp(7): warning.

Ошибка C4700 использована неинициализированная локальная переменная
// ConsoleApplication15.cpp: определяет точку входа для консольного приложения. // #include.

Источник

использована неинициализированная локальная переменная «info»

Выдает ошибку «использована неинициализированная локальная переменная «flag» » и с переменной «sum_check» та же проблема
//func.cpp #include using namespace std; #include «func.h» //Функция, которая.

«Использована неинициализированная локальная переменная» при работе с указателем
использована неинициализированная локальная переменная ukaz . Прошу посмотрите на функцию.

Warning C4700: использована неинициализированная локальная переменная «matrix»
тогда еще 1 вопрос: при попытке реализовать чтение из файла в виде функции: #include .

Ошибка «error C4700: использована неинициализированная локальная переменная»
Здравствуйте! Есть задача: Дана вещественная матрица размерностью 8×8. Определить: 1) сумму.

Функция PTinqpoint() и ошибка «Использована неинициализированная локальная переменная»
Добрый день, возникает проблема с реализацией функции. Документация по ней: PTinqpoint int32.

Error C4700: использована неинициализированная локальная переменная «j»
Постоянно ругается на неинициализированную переменную на 23 строчке, хотя я инициализирую её во.

Warning C4700: использована неинициализированная локальная переменная «d»
#include #include #include using namespace std; int main() <.

Источник

Проклятие неинициализированных переменных

Авторизуйтесь

Проклятие неинициализированных переменных

Позволять программистам использовать неинициализированные переменные — большая ошибка со стороны разработчиков языка. Например, это может привести к значению undefined в JavaScript, которое чревато сопутствующими ошибками.

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

Проблема

Локальные переменные, переменные-поля и т. д. представляют собой неинициализированные переменные, то есть в них будет записано ровно то, что было записано в отведенной под них памяти при объявлении. В C++ существуют различные правила для работы с неинициализированными переменными, инициализированными переменными и нуль-инициализированными переменными. Очень путанный механизм.

Учитывая частоту, с которой в коде появляются неинициализированные переменные, можно подумать, что отследить подобные ситуации в коде легко. Совсем нет. Да, конечно же, большая часть автоматически инициализируется нулем, если не указано иное. Однако так происходит не всегда. Например, в результате выполнения этого кода:

В результате выполнения этого кода у автора статьи всегда печатается False и 0 . Ошибок, связанных с утечкой памяти, можно избежать, используя valgrind .

New Media , Санкт-Петербург, Москва, можно удалённо , По итогам собеседования

Но основная проблема заключается в том, что программы даже в таком случае продолжают работать, что снижает вероятность обнаружения ошибки. Обычно ее можно отследить, только лишь запустив тестирование на другой платформе.

Почему ноль?

Почему программа автоматически инициализирует переменную нулем? На самом деле, это делает не программа, а операционная система, которая просто не позволит приложению проникнуть в неинициализированную область памяти, такова природа этого защитного механизма. Если программа A отработала свое, и результаты ее работы остались где-то в памяти, то программа B не должна обнаружить их во время своей работы, а потому ядро самостоятельно очищает память. В частности, Linux прописывает в освободившуюся память нули.

Естественно, нет никакого правила, чем заполнять память. Вероятно, OpenBSD делает это как-то иначе. Иначе чистит память и ArchLinux, запущенный в VirtualBox. Этим может заниматься не только операционная система — то же может проделать и другая программа, например. И если вдруг в область памяти, которую использует приложение, попадут какие-нибудь значения, изменить их сможет уже только сама эта программа.

Любопытно, что это стало одной из причин появления Heartbleed бага.

Решение

Язык просто не должен позволять использовать неинициализированные переменные. Необязательно нужно указывать конкретное значение — значение просто обязательно должно быть. Например, значением по умолчанию может стать все тот же ноль. Вне зависимости от того, как и в какой области видимости я создал данную переменную.

В то же время, могут быть сделаны определенные исключения в пользу оптимизации. Например, при работе с памятью на низком уровне. Впрочем, оптимизатор обычно обнаруживает неиспользуемые переменные и может их принудительно не инициализировать. Если нам нужен блок неинициализированной памяти, у нас должна быть возможно выделить ее самостоятельно. В этом случае программист четко отдает себе отчет в производимых им действиях, а потому не должен попасть в ловушку.

И чтобы полностью отследить все моменты с инициализацией памяти, язык также должен иметь специальное значение noinit , которое будет показывать, что данная переменная не нуждается в инициализации.

Автор статьи уверен, что уже в ближайшем стандарте C++ должны быть реализованы эти изменения. Превращение неинициализированных ранее переменных в инициализированные не повлияет на корректность выполнения ни одной программы. Такое нововведение будет полностью backwards compatible, и серьезно улучшит популярный язык.

Источник