Какова цель пустого указателя?

Пустой указатель к объектам, что 0 к числам.

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

может казаться очевидным сначала, что это не должно означать "значение", но что это НА САМОМ ДЕЛЕ означает, зависит от контекста. Если, например, пустой указатель LastName ===, который означает, что у человека нет фамилии, или что мы не знаем то, что их фамилия, или что это не имеет, вводится в систему уже? Пустой указатель равняется себе или не делает этого? В SQL это не делает. На многих языках это делает. Но если мы не знаем значение personA.lastName или personB.lastName, как мы можем знать тот personA.lastName === personB.lastName, а? Если результатом является ложь, или... пустой указатель?

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

Вы очень более обеспечены ясно определение ДОМЕНА возможных значений lastName, и точно что каждое возможное значение на самом деле означает, а не в зависимости от некоторого неопределенного понятия в масштабе всей системы пустого указателя, который может или не может иметь никакого отношения к тому, что Вы делаете, в зависимости от которого языка Вы используете, и что Вы пытаетесь сделать. Значение, которое может на самом деле, ведет себя точно неправильным способом, когда Вы начинаете воздействовать на свои данные.

Используйте шаблон несуществующего объекта!

, Если Вы язык объектно-ориентированы, позвольте ему иметь UndefinedValue, класс которого только один одноэлементный экземпляр существует. Тогда используйте этот экземпляр везде, где null используется. Это имеет преимущество, которое Ваш null ответит на сообщения такой как #toString и #equals. Вы никогда не будете сталкиваться с исключением нулевого указателя как в Java. (Конечно, это требует, чтобы Ваш язык был с динамическим контролем типов).

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

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

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

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

при создании динамически типизированного языка ПУСТОЙ УКАЗАТЕЛЬ может войти довольно удобный, поскольку это - просто другой "тип" без любых изменений.

, Что обеспечивает цель пустой указатель?

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

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

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

у Вас есть какие-либо мысли, специально для или против пустого указателя?

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

Нижняя строка, все это зависит от целей Вашего языка:

1. целевая аудитория программирования
2. устойчивость
3. производительность
4. и т.д.

, Если устойчивость и правильность программы высоки в Вашем списке приоритетов И Вы позволяете программные ссылки памяти, Вы захотите рассмотреть пустой указатель.

BB

Еще один способ посмотреть на пустой указатель состоит в том, что это - проблема производительности. Если у Вас есть сложный объект, содержащий другие сложные объекты и так далее, то более эффективно позволить, чтобы все свойства первоначально стали пустыми вместо того, чтобы создать некоторые пустые объекты, которые не будут ни на что не годны и скоро быть замененными.

Это - всего одна перспектива, которую я не вижу упомянутый прежде.

То решение зависит от цели языка программирования.

, Для кого Вы разрабатываете язык программирования? Вы разрабатываете его для людей, которые знакомы с c-derived языками? Если так, тогда необходимо, вероятно, добавить поддержку пустого указателя.

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

Берут блоки переключателя в C# как пример. Все маркировки случая в C# должны иметь явное выражение потока управления в каждом ответвлении. Это, они должны все закончить или оператором "повреждения" или явным goto. Это означает это, в то время как этот код законен:

switch(x)
{
    case 1:
    case 2:
        foo;
        break;
}

, Что этот код не был бы законен:

switch (x)
{
    case 1:
        foo();
    case 2:
        bar();
        break;
}

для создания "падения" через из случая 1 для преобразования регистра 2, необходимо вставить goto, как это:

switch (x)
{
    case 1:
        foo();
        goto case 2;
    case 2:
        bar();
        break;
}

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

, Если бы Ваша цель состоит в том, чтобы разработать язык, предназначенный для программистов на C++, то удаление пустого указателя, вероятно, нарушило бы их ожидания. Это вызовет беспорядок и сделает Ваш язык более трудным учиться. Ключевой вопрос тогда, "что преимущество они добираются"? Или, альтернативно, "какой вред делает эту причину".

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

Так, для резюме я сказал бы, что Вы должны:

1. Определяют Ваши цели в создании языка. Кто язык, разработанный для, и что является их потребностями.
2. Принимают решение на основе того, что помогает целевым пользователям удовлетворить своим целям лучшим способом.

Обычно это будет делать желаемый результат довольно ясным.

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

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

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

мне нравится пустой указатель. Если бы не было никакого пустого указателя, то пустой указатель был бы только заменен некоторым другим путем к коду, чтобы сказать, что "У меня нет подсказки, чувака!" (который некоторые записали бы, "Что у меня нет подсказки, человека!", или "У меня нет подсказки, старина!" и т.д. и так, у нас были бы те же самые проблемы снова).

я делаю вывод, я знаю.

Рассмотрите примеры C и Java, например. В C конвенция состоит в том, что нулевой указатель является нулем числового значения. Конечно, это - действительно просто конвенция: ничто об обработках языка, которые оценивают как что-либо специальное. В Java, однако, null отличное понятие, которое можно обнаружить и знать, что, да, это - на самом деле неверная ссылка, и я не должен пытаться открыть ту дверь для наблюдения то, что с другой стороны.

, Несмотря на это, я ненавижу, аннулирует почти хуже, чем что-либо еще.

РАЗЪЯСНЕНИЕ на основе комментариев: Я ненавижу defacto значение нулевого указателя нуля, хуже, чем я ненавижу null.

Любое время я вижу присвоение на пустой указатель, я думаю, "о, хороший, кто-то только что поместил мину в код. Когда-нибудь, мы собираемся быть спуском со связанного пути выполнения и БУМ ! NullPointerException!"

то, Что я предпочел бы, - чтобы кто-то определил полезное значение по умолчанию или NullObject, который сообщает мне, что "этот параметр не был установлен ни на что полезное". Лысый пустой указатель отдельно является просто неизбежной проблемой.

Тем не менее это еще лучше, чем необработанный нуль, блуждающий вокруг свободного.

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

Пустой указатель не является ошибкой. Пустой указатель означает, что "Я еще не знаю"

Для примитивов, Вам действительно не нужен пустой указатель (я должен сказать, что строки (в.NET) не должны получать его, по моему скромному мнению)

, Но для составных объектов он определенно служит цели.

Можно думать о любом типе как о наборе наряду с набором операций. Существует много случаев, где удобно иметь значение с, не "нормальное" значение; например, рассмотрите значение "EOF". для C getline(). Можно обработать это одним из нескольких способов: у Вас может быть Нулевое значение вне набора, можно отличить конкретное значение как пустой указатель (в C, ((void *)0) может служить той цели), или у Вас может быть способ создать новый тип, так, чтобы для типа T , Вы создали тип T' =def {T ∪ ПУСТОЙ УКАЗАТЕЛЬ} , который является путем Haskell, делает это ("Возможно", тип).

то, Какой лучше, хорошо для большого количества приятного аргумента.

В ПУСТОМ УКАЗАТЕЛЕ C был (пусто* (0)), таким образом, это был тип со значением (?). Но это не работало с шаблонами C++ так C++, сделанный ПУСТЫМ 0, он отбросил тип и стал чистым значением.

Однако было найдено, что наличие определенного ПУСТОГО типа будет лучше, таким образом, они (комитет по C++) решили, что ПУСТОЙ УКАЗАТЕЛЬ еще раз станет типом (в C++ 0x).

Также почти каждый язык помимо C++ имеет ПУСТОЙ УКАЗАТЕЛЬ как тип или эквивалентное уникальное значение не то же как 0 (это могло бы быть равно ему или нет, но не то же значение).

Так же теперь даже C++ будет использовать ПУСТОЙ УКАЗАТЕЛЬ как тип, в основном заключительный обсуждения вопроса, так как теперь у всех (почти) будет ПУСТОЕ Редактирование типа

: Взгляды об этом Haskell, возможно, является другим решением АННУЛИРОВАТЬ типы, но не как легкие схватить или реализовать.

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

Я не думаю, что полезно говорить о пустом указателе вне контекста целого дизайна языка. Первая точка беспорядка: действительно ли пустой тип пуст, или он включает единственное, выдающееся значение (часто названный "нолем")? Абсолютно пустой тип не является очень полезным---, хотя C использует пустой тип void возврата для маркировки процедуры, которая выполняется только для побочного эффекта, много других языков используют одноэлементный тип (обычно пустой кортеж) с этой целью.

я нахожу, что нулевое значение используется наиболее эффективно на динамически типизированных языках. В Smalltalk это - значение, используемое, когда Вам нужно значение, но у Вас нет информации. В Lua это используется еще эффективнее: нулевое значение является единственным значением, которое не может быть ключом или значением в таблице Lua. В Lua ноль также используется в качестве значения недостающих параметров или результатов.

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

Любой ценой, избегайте NULL указатель используемый в C и Java. Это артефакты, свойственные от реализаций указателей и объектов, и на хорошо разработанном языке им нельзя позволить. Любой ценой дайте Вашим пользователям, которых путь к расширяет существующий тип с помощью нулевого значения, но заставляет их сделать, он явно, нарочно---не вынуждает каждый тип иметь тот случайно. (Как пример конкретного вида использования, я недавно реализовал Бентли и троичные деревья поиска Sedgewick в Haskell, и я должен был расширить тип символов с помощью одного дополнительного значения, означающего 'не символ'. С этой целью Haskell обеспечивает эти Maybe тип.)

Наконец, если Вы пишете компилятор, хорошо помнить, что самые легкие части языка для компиляции, и части, которые вызывают наименьшее количество ошибок, являются частями, которые не являются там:-)

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

Я обычно думаю о 'пустом указателе' в аспекте C/C++ 'адреса памяти 0'. Не строго необходимо, но если бы это не существовало, тогда то люди просто использовали бы что-то еще (если myNumber ==-1, или если myString =="").

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

В мире.NET, MS недавно добавил nullable типы для интервала, долго, и т.д. который никогда раньше не был nullable, таким образом, я предполагаю, что они думают его довольно важное также.

, Если бы я разрабатывал lanaguage, я сохранил бы его. Однако я не избегал бы использования языка, который не имел пустого указателя также. Просто потребовалось бы немного привыкающее также.

Что является пустым для Вас, спрашивают?

ну,

Ничто.

О нет я чувствую философию основной выход из меня....

понятие ПУСТОГО УКАЗАТЕЛЯ прибывает из понятия пустого множества в теории множеств. Почти все соглашаются, что пустое множество не равно нулю. Математики и философы боролись о значении теории множеств в течение многих десятилетий.

На языках программирования, я думаю, что очень полезно понять ссылки на объект, которые ни к чему не относятся в памяти. Google о теории множеств и Вы будете видеть общие черты между формальными символьными системами (нотация), которые устанавливают использование теоретиков и символы, которые мы используем на многих языках программирования.

С уважением, Sam

null значение сигнальной метки, которое не является целым числом, не строкой, не булевской переменной - ничто действительно, кроме чего-то, чтобы содержать и быть "не там" значением. Не рассматривайте его как или ожидайте, что он будет 0, или пустой строкой или пустым списком. Это - все допустимые значения и может быть geniunely допустимыми значениями при многих обстоятельствах - идея пустого указателя вместо этого означает, что существует никакой значение там.

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

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

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

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

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