Что вы можете сделать по этому поводу?
Здесь есть много хороших ответов, объясняющих, что такое пустая ссылка и как ее отладить. Но очень мало о том, как предотвратить проблему или, по крайней мере, сделать ее легче поймать.
Проверить аргументы
Например, методы могут проверять разные аргументы, чтобы увидеть, null и выбросить ArgumentNullException
, исключение, явно созданное для этой конкретной цели.
Конструктор для ArgumentNullException
даже принимает имя параметра и сообщение как аргументы, чтобы вы могли точно сказать разработчику, что проблема.
public void DoSomething(MyObject obj) {
if(obj == null)
{
throw new ArgumentNullException("obj", "Need a reference to obj.");
}
}
Использовать инструменты
Есть также несколько библиотек, которые могут помочь. Например, «Resharper» может предоставить вам предупреждения во время написания кода, особенно если вы используете их атрибут: NotNullAttribute
В разделе «Контракты кода Microsoft» вы используете синтаксис, например Contract.Requires(obj != null)
, который дает вам проверку выполнения и компиляцию: Представление кодовых контрактов .
Существует также «PostSharp», который позволит вам просто использовать такие атрибуты:
public void DoSometing([NotNull] obj)
Сделав это и сделав PostSharp частью вашего процесса сборки, obj
будет проверяться на нуль во время выполнения. См. Ошибка проверки PostSharp
Решение для простого кода
Или вы всегда можете использовать свой собственный подход, используя простой старый код. Например, вот структура, которую вы можете использовать, чтобы поймать нулевые ссылки. Он моделируется после той же концепции, что и Nullable
:
[System.Diagnostics.DebuggerNonUserCode]
public struct NotNull where T: class
{
private T _value;
public T Value
{
get
{
if (_value == null)
{
throw new Exception("null value not allowed");
}
return _value;
}
set
{
if (value == null)
{
throw new Exception("null value not allowed.");
}
_value = value;
}
}
public static implicit operator T(NotNull notNullValue)
{
return notNullValue.Value;
}
public static implicit operator NotNull(T value)
{
return new NotNull { Value = value };
}
}
. Вы использовали бы очень похоже на то, как вы бы использовали Nullable
, за исключением того, что цель заключалась в том, чтобы сделать абсолютно противоположное - не разрешать null
. Вот несколько примеров:
NotNull person = null; // throws exception
NotNull person = new Person(); // OK
NotNull person = GetPerson(); // throws exception if GetPerson() returns null
NotNull
неявно отбрасывается в и из T
, поэтому вы можете использовать его в любом месте, где это необходимо. Например, вы можете передать объект Person
методу, который принимает значение NotNull
:
Person person = new Person { Name = "John" };
WriteName(person);
public static void WriteName(NotNull person)
{
Console.WriteLine(person.Value.Name);
}
Как вы можете видеть выше, как с помощью nullable, вы получите доступ к базовому значению через Value
имущество. Кроме того, вы можете использовать явный или неявный листинг, вы можете увидеть пример с возвращаемым значением ниже:
Person person = GetPerson();
public static NotNull GetPerson()
{
return new Person { Name = "John" };
}
Или вы даже можете использовать его, когда метод просто возвращает T
(в этом случае Person
), выполнив бросок. Например, следующий код будет похож на код выше:
Person person = (NotNull)GetPerson();
public static Person GetPerson()
{
return new Person { Name = "John" };
}
Объединить с Extension
Объединить NotNull
с методом расширения, и вы можете охватить еще больше ситуаций. Вот пример того, как может выглядеть метод расширения:
[System.Diagnostics.DebuggerNonUserCode]
public static class NotNullExtension
{
public static T NotNull(this T @this) where T: class
{
if (@this == null)
{
throw new Exception("null value not allowed");
}
return @this;
}
}
И вот пример того, как он может быть использован:
var person = GetPerson().NotNull();
GitHub
Для вашей справки я сделал код выше, доступный на GitHub, вы можете найти его по адресу:
https://github.com/luisperezphd/NotNull
Функция родственного языка
В C # 6.0 был введен «оператор с нулевым условием», который немного помогает в этом. С помощью этой функции вы можете ссылаться на вложенные объекты, и если какой-либо из них null
, все выражение возвращает null
.
Это уменьшает количество нулевых проверок, которые вы должны выполнять в некоторых случаях. Синтаксис заключается в том, чтобы поставить вопросительный знак перед каждой точкой. Возьмите следующий код, например:
var address = country?.State?.County?.City;
Представьте, что country
является объектом типа Country
, который имеет свойство, называемое State
и т. Д. Если country
, State
, County
или City
- null
, то address will be
null . Therefore you only have to check whether
адрес is
null`.
Это отличная функция, но она дает вам меньше информации. Это не делает очевидным, какой из 4 является нулевым.
Встроенный как Nullable?
C # имеет красивую стенографию для Nullable
, вы можете сделать что-то нулевое помещая знак вопроса после такого типа int?
.
Было бы неплохо, если бы у C # было что-то вроде структуры NotNull
выше и имела аналогичную стенографию, может быть, восклицательный знак (!), чтобы вы могли написать что-то вроде: public void WriteName(Person! person)
.
Используйте std::modf
:
double intpart;
modf(value, &intpart) == 0.0
Не конвертируйте в int
! Число 1.0e+300
также является целым числом.
Редактирование: как указывает Пит Киркхам, передавая 0, поскольку второй аргумент не гарантируется стандартом для работы, требуя использования фиктивной переменной и , к сожалению, делает код намного менее изящным.
Как насчет этого?
if ((d1 - (int)d1) == 0)
// integer
Я столкнулся с подобными вопросами. Поскольку мне все равно нужно было обойти двойник, вот что я нахожу:
double d = 2.000000001;
int i = std::round(d);
std::fabs(d-i) < 10 * std::numeric_limits<double>::epsilon()
Как насчет
if (abs(d1 - (round(d1))) < 0.000000001) {
printf "Integer\n"; /* Can not use "==" since we are concerned about precision */
}
Исправлено использование работы с округлением для отражения ошибки Anna found
Альтернативные решения:
if ((d1 - floor(d1) < 0.000000001) || (d1 - floor(d1) > 0.9999999999)) {
/* Better store floor value in a temp variable to speed up */
printf "Integer\n"; /* Can not use "==" since we are concerned about precision */
}
Theres также еще один с занятием, вычитая 0,5 и принимая abs () этого и сравнивая с 0.499999999, но я полагаю, что это не будет основным улучшением производительности.
Ниже у вас есть код для тестирования d1 и d2, который очень прост. Единственное, что вам нужно проверить, - это значение переменной равно тому же значению, преобразованному в тип int. Если это не так, то это не целое число.
#include<iostream>
using namespace std;
int main()
{
void checkType(double x);
double d1 = 555;
double d2 = 55.343;
checkType(d1);
checkType(d2);
system("Pause");
return 0;
}
void checkType(double x)
{
if(x != (int)x)
{
cout<< x << " is not an integer "<< endl;
}
else
{
cout << x << " is an integer " << endl;
}
};
Во многих вычислениях вы знаете, что ваши результаты с плавающей запятой будут иметь небольшую числовую ошибку, которая может возникнуть в результате ряда умножений.
Так что вы действительно можете найти, так это вопрос в том, что это число внутри скажем, 1е-5 целочисленного значения. В этом случае я думаю, что это работает лучше:
bool isInteger( double value )
{
double flr = floor( value + 1e-5 );
double diff = value - flr;
return diff < 1e-5;
}
#include <math.h>
#include <limits>
int main()
{
double x, y, n;
x = SOME_VAL;
y = modf( x, &n ); // splits a floating-point value into fractional and integer parts
if ( abs(y) < std::numeric_limits<double>::epsilon() )
{
// no floating part
}
}
int iHaveNoFraction(double d){
return d == trunc(d);
}
Теперь это не было бы C, если бы у него не было около 40 лет языковых версий ...
В C, ==
возвращает int
, но в C ++ он возвращает bool
. По крайней мере, на моем Linux-дистрибутиве (Ubuntu) вам нужно либо объявить double trunc(double);
, либо вы можете скомпилировать с -std=c99
или объявить макрос уровня, чтобы получить <math.h>
, чтобы объявить его.
int
. Я прояснил ситуацию ...
– DigitalRoss
5 October 2009 в 19:42
<math.h>
i> и соответствующими реализациями , что i> должны иметь trunc()
. Но да, может быть безопаснее использовать floor ().
– DigitalRoss
5 October 2009 в 20:21
try:
bool isInteger(double d, double delta)
{
double absd = abs(d);
if( absd - floor(absd) > 0.5 )
return (ceil(absd) - absd) < delta;
return (d - floor(absd)) < delta;
}
avakar был почти прав - используйте modf, но детали были отключены.
modf возвращает дробную часть, поэтому тест должен состоять в том, что результат modf равен 0.0.
modf принимает два аргумента, второй из которых должен быть указателем того же типа, что и первый аргумент. Передача NULL или 0 вызывает ошибку сегментации в среде выполнения g ++. В стандарте не указывается, что передача 0 безопасна; возможно, это работает на машине Авакара, но не делайте этого.
Вы также можете использовать fmod(a,b)
, который вычисляет a
по модулю b
, проходящий 1.0. Это также должно дать дробную часть.
#include<cmath>
#include<iostream>
int main ()
{
double d1 = 555;
double d2 = 55.343;
double int_part1;
double int_part2;
using namespace std;
cout << boolalpha;
cout << d1 << " " << modf ( d1, &int_part1 ) << endl;
cout << d1 << " " << ( modf ( d1, &int_part1 ) == 0.0 ) << endl;
cout << d2 << " " << modf ( d2, &int_part2 ) << endl;
cout << d1 << " " << ( modf ( d2, &int_part2 ) == 0.0 ) << endl;
cout << d2 << " " << modf ( d2, &int_part2 ) << endl;
cout << d1 << " " << ( modf ( d2, &int_part2 ) == 0.0 ) << endl;
cout << d1 << " " << fmod ( d1, 1.0 ) << endl;
cout << d1 << " " << ( fmod ( d1, 1.0 ) == 0 ) << endl;
cout << d2 << " " << fmod ( d2, 1.0 ) << endl;
cout << d2 << " " << ( fmod ( d2, 1.0 ) == 0 ) << endl;
cout.flush();
modf ( d1, 0 ); // segfault
}
modf
. Благодарю.
– avakar
5 October 2009 в 20:35
Предполагая, что среда, совместимая с c99 и IEEE-754,
(trunc(x) == x)
является другим решением и будет (на большинстве платформ) иметь немного лучшую производительность, чем modf
, потому что ей нужно только произвести целое число часть.
Обратите внимание, что trunc
дает результат с двойной точностью, поэтому вам не нужно беспокоиться о преобразованиях вне диапазона, как это было бы с (int)x
.
Изменить: как указывает @pavon в комментарии, вам может потребоваться добавить еще одну проверку, в зависимости от того, заботитесь о бесконечности или нет, и какой результат вы хотите получить, если x
бесконечен.
Предполагая, что у вас есть библиотека cmath <math.h>
, вы можете проверить число против floor . Если число может быть отрицательным, убедитесь, что вы сначала получаете absolute .
bool double_is_int(double trouble) {
double absolute = abs( trouble );
return absolute == floor(absolute);
}
Пример фрагмента кода, который делает это:
if ( ABS( ((int) d1) - (d1)) )< 0.000000001)
cout <<"Integer" << endl;
else
cout <<"Flaot" << endl;
EDIT: Изменено, чтобы отобразить правильный код.
modf
до сих пор. – GManNickG 5 October 2009 в 19:35NULL
вместо0
, но я понимаю, что это довольно спорная проблема на C ++, без уважительной причины. – Chris Lutz 5 October 2009 в 19:44