default(int?) = null
default(string?) = null
default(int) = 0
default(string) = ?

default(string?) = null
default(string) = string.Empty

A>default(int?) = null
A>default(string?) = null
A>default(int) = 0
A>default(string) = ?
A>

Initialize the property to null

As a terser alternative to using a nullable backing field, or if the library that instantiates your class is not compatible with that approach, you can simply initialize the property to null directly, with the help of the null-forgiving operator (!):

[Required]
public string FirstName { get; set; } = null!;

[Required]
public string LastName { get; set; } = null!;

public string? VehicleRegistration { get; set; }

You will never observe an actual null value at runtime except as a result of a programming bug, by accessing the property before it has been properly initialized.

void foo(A *a)
{
  // здесь a может быть null и нужно добавлять проверку
}

void foo(A &a)
{
  // здесь a не null и можно работать с объектом без доп. проверок
}

public: void f(A *a)
{
  if(a == null) return;
  for(million...times) {
    g(a);
  } 
}

private: void g(A *a)
{
//вот тут ты будешь проверять a==null?
}

 foo2(*obj);

K>Меня всегда удивляло почему сразу в шарпе ничего похожего не сделали и заставили везде эти проверки на null писать

type Person = {
    Name : string
    Note : string option
}

type Date = System.DateTime
type Id = System.Int32

let report person =
    match person.Note with
        | None -> printfn "%s не содержит описания" person.Name
        | Some note -> printfn "%s (%s)" person.Name note


report {Name = "Alice"; Note = None }        
report {Name = "Bob"; Note = Some "Bad programmer" }  
report null // error FS0043: Тип "Person" не содержит собственное значение "null"

После установления ссылки мы можем через нее манипулировать самим объектом, на который она ссылается:

int main()
{
    int number = 5;
    int &refNumber = number;
    std::cout << refNumber << std::endl; // 5
    refNumber = 20;
    std::cout << number << std::endl;   // 20
         
    return 0;
}

void foo(ref A a)
{
  if (a == null)
    throw new ArgumentNullException();

  a = new A();
}

...
A a = new A();
A b = a;
foo(ref a);
// Что тут вернёт b == a; ?
b = null;
foo(ref b); // а вот так я могу передать null

public struct NotNullableString
{
    public NotNullableString(string value)
    {
      Value = value ?? string.Empty;
    }

    public string Value { get; }
}

public struct NotNullable<T>
    where T : class
{
    public NotNullable(T value)
    {
      if (value == null)
        throw new ArgumentNullException();
      Value = value;
    }

    public T Value { get; }
}

K>void foo(ref A a)
K>{
K>  if (a == null)
K>    throw new ArgumentNullException();

K>  a = new A();
K>}

K>...
K>A a = new A();
K>A b = a;
K>foo(ref a);
K>// Что тут вернёт b == a; ?
K>b = null;
K>foo(ref b); // а вот так я могу передать null
K>

int main()
{
    int a = 4;
    int b = 5;
    std::cout << "Before square: a = " << a << "\tb=" << b << std::endl;
    square(a, b);
    std::cout << "After square: a = " << a << "\tb=" << b << std::endl;
 
    return 0;
}
void square(int &a, int &b)
{
    a = a * a;
    b = b * b;
    std::cout << "In square: a = " << a << "\tb=" << b << std::endl;
}

void square(*int &a, *int &b)
{
    *a = *a * *a;
    *b = *b * *b;
}

S>>void square(*int &a, *int &b)
S>>{
S>>    *a = *a * *a;
S>>    *b = *b * *b;
S>>}
S>>

K>В ответ какая-то околесица вместо такого же прямого решения. В чём прикол?

void square(*int &a, *int &b)
{
    *a = *a * *a;
    *b = *b * *b;
}

void square(ref int a, ref int  b)
{
    a = a * a;
    b = b * b;
}

S>>·> Так это ж int, он примитивный тип, он не может быть null. Этот ref вообще к теме не относится и никаких проблем не решает, так, сахар синтаксический.

void square(*char &a, *char &b)

int main()
{
    A *obj = new A(0); // Создаём объект примерно как в C#
    
    cout << obj->Value << endl;
    
    // тут так уж и быть проверим, что указатель не null перед получением ссылки
    if (obj == nullptr)
        throw "NullReferenceException";
    foo1(*obj);
    // тут на null не нужно проверять, т.к. при передаче по ссылке указатель не мог стать null, т.е. переменная obj не менялась
    cout << obj->Value << endl;
}

class Program
    {
        static int[] testArray = new int[] { 1, 2, 3 };
        static void Test(ref int d)
        {
            d = 5;
        }

        static ref int Test( int d)
        {
            return ref testArray[d];
        }

        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            int r = 4;

            ref int d = ref r;
            Test(ref d);

            ref int d2 = ref Test(1);

            Test(ref d2);

            Console.WriteLine(testArray[1].ToString());
        }
    }

K>Эта проверка собственно и сейчас есть при конвертации int? в int

static string? GetNullableString()

static void Тест1(string s)
{
// проверка на null не нужна
Тест2(s);
}

static void Тест2(string s)
{
// проверка на null не нужна
}


var s=GetNullableString();

 if (s==null)
   вызовем исключение 


Тест1(s!);