Что пусто означает в C, C++ и C#?

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

, например

void MethodThatReturnsAndTakesVoid(void)
{
// Method body
}

В C # мы можем опустить пустоту для параметров и написать приведенный выше код как:

void MethodThatReturnsAndTakesVoid()
{
// Method body
}

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

Если вы объясняете концепцию новичку, возможно, будет полезно использовать аналогию. Использование void во всех этих случаях аналогично значению страницы в книге со следующими словами: «Эта страница намеренно оставлена ​​пустой». Это делается для того, чтобы компилятор различал то, что должно быть помечено как ошибка, и тип, который намеренно должен быть оставлен пустым, потому что это именно то поведение, которое вы хотите.

Оно всегда появляется в коде там, где вы обычно ожидаете увидеть появляется тип, такой как тип возвращаемого значения или тип указателя. Вот почему в C # void сопоставляется с фактическим типом CLR, System.Void, потому что это тип сам по себе.

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

Void является эквивалентом подпрограммы Visual Basic.

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

• R f (void) - Параметры функции отсутствуют
• void f (P) - Return значение отсутствует
• void * p - Тип того, на что указывает, отсутствует
• (void) p - Использование значения отсутствует

Другое Потомки C используют его для других целей. Язык программирования D использует его для случаев, когда инициализатор отсутствует

• T t = void; - значение инициализации отсутствует

В C # вы должны использовать ключевое слово void, чтобы указать, что метод не возвращает значение:

public void DoSomeWork()
{
//some work
}

Это означает «нет значения». Вы используете void , чтобы указать, что функция не возвращает значение или что у нее нет параметров, или и то, и другое. В значительной степени соответствует типичному использованию слова void в английском языке.

Указывает на отсутствие возвращаемого значения в функции.

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

В C и его производных разница между ними не является явной. По сути, все является функцией. ключевое слово void указывает, что это не «настоящая» функция, поскольку оно не возвращает значение.

Три варианта использования void:

1. Сигнатуры функций. void foo (int bar) не возвращает значение. int bar (void) не принимает никаких параметров, но обычно это выражается пустым списком аргументов: int bar () . Использование ключевого слова void здесь соответствует его значению на английском языке.

2. Общий указатель верхнего типа void * , который указывает на неопределенные данные и не может быть разыменован. Здесь значение void отличается от других значений void: универсальный тип против отсутствия типа.

3. В приведениях типа (void) new Foo (this) , чтобы указать, что возвращаемое значение намеренно отбрасывается. Здесь использование ключевого слова также соответствует его значению на английском языке.

Случаи 1 и 2 уже были рассмотрены @Gerald, но случай 3 еще не рассмотрен.

Void means no value required in return type from a function in all of three language.

void mean that you won't be returning any value form the function or method

There are two ways to use void:

void foo(void);

or

void *bar(void*);

The first indicates that no argument is being passed or that no argument is being returned.

The second tells the compiler that there is no type associated with the data effectively meaning that the you can't make use of the data pointed to until it is cast to a known type.

For example you will see void* used a lot when you have an interface which calls a function whose parameters can't be known ahead of time.

For example, in the Linux Kernel when deferring work you will setup a function to be run at a latter time by giving it a pointer to the function to be run and a pointer to the data to be passed to the function:

struct _deferred_work {
sruct list_head mylist;
.worker_func = bar;
.data        = somedata;
} deferred_work;

Then a kernel thread goes over a list of deferred work and when it get's to this node it effectively executes:

bar(somedata);

Then in bar you have:

void bar(void* mydata) {
    int *data = mydata;
    /* do something with data */;
}

Think of void as the "empty structure". Let me explain.

Every function takes a sequence of parameters, where each parameter has a type. In fact, we could package up the parameters into a structure, with the structure slots corresponding to the parameters. This makes every function have exactly one argument. Similarly, functions produce a result, which has a type. It could be a boolean, or it could be float, or it could be a structure, containing an arbitrary set of other typed values. If we want a languge that has multiple return values, it is easy to just insist they be packaged into a structure. In fact, we could always insist that a function returned a structure. Now every function takes exactly one argument, and produces exactly one value.

Now, what happens when I need a function that produces "no" value? Хорошо, подумайте, что я получаю, когда формирую структуру с 3 слотами: это содержит 3 значения. Когда у меня есть 2 слота, он содержит два значения. Когда это имеет один слот, одно значение. И когда в нем ноль слотов, он держит ... э-э, нулевые значения или «нет» значения. Итак, я могу думать о функции, возвращающей void как возвращение структуры, не содержащей значений. Вы даже можете решить, что "пустота" это просто синоним типа, представленного пустой структурой, вместо ключевого слова в языке (возможно, это просто предопределенный тип :)

Точно так же я могу думать о функции, не требующей значений, как о принимающей пустую структуру, например, «void».

Я даже могу реализовать свой язык программирования таким образом. Передача пустого значения занимает ноль байтов, поэтому передача пустых значений - это просто частный случай передачи другие значения произвольного размера. Это позволяет компилятору легко обрабатывать the "void" result or argument. You probably want a langauge feature that can throw a function result away; in C, if you call the non-void result function foo in the following statement: foo(...); the compiler knows that foo produces a result and simply ignores it. If void is a value, this works perfectly and now "procedures" (which are just an adjective for a function with void result) are just trivial special cases of general functions.

Void* is a bit funnier. I don't think the C designers thought of void in the above way; they just created a keyword. That keyword was available when somebody needed a point to an arbitrary type, thus void* as the idiom in C. It actually works pretty well if you interpret void as an empty structure. A void* pointer is the address of a place where that empty structure has been put.

Casts from void* to T* for other types T, also work out with this perspective. Pointer casts are a complete cheat that work on most common architectures to take advantage of the fact that if a compound type T has an element with subtype S placed physically at the beginning of T in its storage layout, then casting S* to T* and vice versa using the same physical machine address tends to work out, since most machine pointers have a single representation. Replacing the type S by the type void gives exactly the same effect, and thus casting to/from void* works out.

The PARLANSE programming language implements the above ideas pretty closely. We goofed in its design, and didn't pay close attention to "void" as a return type and thus have langauge keywords for procedure. Its mostly just a simple syntax change but its one of things you don't get around to once you get a large body working code in a language.