In TypeScript, you can annotate a function as returning `void`:

    function fn1(): void {
      // OK
    }

    function fn2(): void {
      // Error
      return 3;
    }

You can also annotate a function to return `undefined`:

    function fn3(): undefined {
      // OK
      return;
    }

    function fn4(): undefined {
      // Error
      return 3;
    }

So it seems that if you call a function returning `void`, you&#39;ll always get back the value `undefined`. Yet you can&#39;t write this code:

    function fn5(): void {
    }
    let u: undefined = fn5(); // Error


Why isn&#39;t `void` just an alias for `undefined`? Does it need to exist at all?

Why does TypeScript have both `void` and `undefined`?

An often used statement like `(void)x;` allows to suppress warnings about unused variable `x`. But if I try compiling the following, I get some results I don&#39;t quite understand:

    int main()
    {
        int x;
        (short)x;
        (void)x;
        (int)x;
    }

Compiling this with g++, I get the following warnings:

    $ g++ test.cpp -Wall -Wextra -o test
    test.cpp: In function ‘int main()’:
    test.cpp:4:13: warning: statement has no effect [-Wunused-value]
         (short)x;
                 ^
    test.cpp:6:11: warning: statement has no effect [-Wunused-value]
         (int)x;
               ^

So I conclude that casting to `void` is very different from casting to any other types, be the target type the same as `decltype(x)` or something different. My guess at possible explanations is:

* It is just a convention that `(void)x;` but not the other casts will suppress warnings. All the statements equally don&#39;t have any effect.
* This difference is somehow related to the fact that `void x;` isn&#39;t a valid statement while `short x;` is.

Which of these if any is more correct? If none, then how can the difference in compiler warnings be explained?

What does casting to `void` really do?

    void run() {
        ...
        if (done) return cancel();
        ...
    }

where `cancel()` return `void`. This won&#39;t compile... and I can *almost* understand why. But if I want to return a void from a void, why not? Instead, I end up writing something like this:

    if (done) {
        cancel();
        return;
    }

I&#39;m not looking for code style suggestions, I want to know why Java expressly prohibits this type of void return. Any info is appreciated, thanks.

Why can&#39;t I explicitly return void from a method?

I am not sure what the difference is between specifying Unit as the return type of my scala method or leaving out the return type altogether. What is the difference?

Can anyone please advise?

Should I use Unit or leave out the return type for my scala method?

From [[5.3.3/1]](http://eel.is/c++draft/expr.sizeof#1), I found that:

&gt; The&#160;sizeof&#160;operator shall not be applied to an expression that has function or incomplete type

From [[3.9/5]](http://eel.is/c++draft/basic.types#5) I found that:

&gt; Incompletely-defined object types and&#160;cv void&#160;are&#160;incomplete types

Anyway, for `sizeof` does not evaluate it&#39;s operands, I would have said that `sizeof(void())` was a legal expression (actually GCC compiles it and the result is 1).  
On the other side, from [here](http://eel.is/c++draft/expr.sizeof), `void` is not mentioned while discussing `sizeof`, neither when the types having size 1 are mentioned, nor in the list of the ones having an _implementation defined_ size.

The question is thus: is `sizeof(void())` a legal expression?  
Is it guaranteed to have size equal to 1?  
Or is it a legal expression resulting in an UB and that&#39;s all?


Is sizeof(void()) a legal expression?

I have an object `myobject`, which might return `None`. If it returns `None`, it won&#39;t return an attribute `id`:

    a = myobject.id

So when myobject is `None`, the stament above results in a `AttributeError`:

    AttributeError: &#39;NoneType&#39; object has no attribute &#39;id&#39;

If `myobject` is None, then I want `a` to be equal to `None`. How do I avoid this exception in one line statement, such as:

    a = default(myobject.id, None)





How can I return a default value for an attribute?

I was testing return types with PHP 7.
 
I&#39;ve created a simple script to test return types of PHP 7:

    &lt;?php
    
    Class Obj {
        
        public function __construct(){
            
        }
        
        public function test(): string { //a string needs to be returned
            return &quot;ok&quot;;
        }
        
    }
    
    function foo(): Obj { //instance of Obj needs to be returned
        return new Obj();
    }
    
    $o = foo();
    echo $o-&gt;test(); // output: ok

Now in other programming languages when you specify a return type `void` it means you cannot return anything or you will get an error. So I wrote this script:

    &lt;?php

        function foo(): void {
    
        }
    
        foo(); 

Now in above script the expected output is nothing. 
Instead it gives me a Fatal error:

&gt;Fatal error: Return value of foo() must be an instance of void, none returned on line 2

My question is (I couldn&#39;t find it), in PHP 7 will there be a similar `void` type?

Void as return type

What exactly is the difference between `undefined` and  `void 0` ?

Which is preferred and why?

JavaScript `undefined` vs `void 0`

Ok, so I have heard different opinions on this subject and just want to make sure I understand it correctly.

## For C++

Declarations `void f();` and `void f(void);` mean precisely the same thing, the function `f` does not take any parameters. Ditto for definitions.

## For C

Declaration `void f(void);` means that `f` does not take any parameters. 

Declaration `void f();` means that function `f` may or may not have parameters, and if it does, we don&#39;t know what kind of parameters those are, or how many there is of them. Note that it is NOT the same as ellipsis, we can&#39;t use `va_list`.

Now here is where things get interesting. 

### Case 1

Declaration:

    void f();

Definition:

    void f(int a, int b, float c)
    {
       //...
    }

### Case 2

Declaration:

    void f();

Definition:

    void f()
    {
       //...
    }

### Question:

What happens at compile time in cases 1 and 2 when we call `f` with the correct arguments, wrong arguments and no arguments at all? What happens at run time?

### Additional question:

If I declare `f` with arguments, but define it without them, will it make a difference? Should I be able to address the arguments from the function body?


Understanding the difference between f() and f(void) in C and C++ once and for all

Let&#39;s say I have the following functional interface in Java 8:

    interface Action&lt;T, U&gt; {
       U execute(T t);
    }

And for some cases I need an action without arguments or return type. So I write
something like this:

    Action&lt;Void, Void&gt; a = () -&gt; { System.out.println(&quot;Do nothing!&quot;); };

However, it gives me compile error, I need to write it as

    Action&lt;Void, Void&gt; a = (Void v) -&gt; { System.out.println(&quot;Do nothing!&quot;); return null;};

Which is ugly. Is there any way to get rid of the `Void` type parameter?




Java 8 lambda Void argument

How to mock methods with void return type? 

I implemented an observer pattern but I can&#39;t mock it with Mockito because I don&#39;t know how.

And I tried to find an example on the Internet but didn&#39;t succeed.

My class looks like this:

    public class World {

        List&lt;Listener&gt; listeners;

        void addListener(Listener item) {
            listeners.add(item);
        }

        void doAction(Action goal,Object obj) {
            setState(&quot;i received&quot;);
            goal.doAction(obj);
            setState(&quot;i finished&quot;);
        }

        private string state;
        //setter getter state
    } 
    
    public class WorldTest implements Listener {
    
        @Test public void word{
        World  w= mock(World.class);
        w.addListener(this);
        ...
        ...
    
        }
    }
    
    interface Listener {
        void doAction();
    }

The system is not triggered with mock.

I want to show the above-mentioned system state. And make assertions according to them.

How to mock void methods with Mockito

What is better: `void foo()` or `void foo(void)`?
With void it looks ugly and inconsistent, but I&#39;ve been told that it is good. Is this true?

Edit: I know some old compilers do weird things, but if I&#39;m using just GCC, is `void foo()` Ok? Will `foo(bar);` then be accepted?

Is it better to use C void arguments &quot;void foo(void)&quot; or not &quot;void foo()&quot;?

What is the best way to unit test a method that doesn&#39;t return anything? Specifically in c#.

What I am really trying to test is a method that takes a log file and parses it for specific strings. The strings are then inserted into a database. Nothing that hasn&#39;t been done before but being VERY new to TDD I am wondering if it is possible to test this or is it something that doesn&#39;t really get tested.

Unit testing void methods?

In python 3.x, it is common to use return type annotation of a function, such as:

    def foo() -&gt; str:
        return &quot;bar&quot;

What is the correct annotation for the &quot;void&quot; type?

I&#39;m considering 3 options:

 1. ``def foo() -&gt; None:``
      - not logical IMO, because ``None`` is not a type,
 2. ``def foo() -&gt; type(None):``
      - using the best syntax I know for obtaining ``NoneType``,
 3. ``def foo():``
      - omit explicit return type information.

Option 2. seems the most logical to me, but I&#39;ve already seen some instances of 1.

Python void return type annotation

There is a Java `Void` -- uppercase V-- [reference type][1]. The only situation I have ever seen it used is to parameterize `Callable`s  

    final Callable&lt;Void&gt; callable = new Callable&lt;Void&gt;() {
                public Void call() {
                    foobar();
                    return null;
                }
            };

Are there any other uses for the Java `Void` reference type? Can it ever be assigned anything other than `null`? If yes, do you have examples?


  [1]: https://docs.oracle.com/javase/9/docs/api/java/lang/Void.html

Uses for the Java Void Reference Type?

Let&#39;s say you have a method or a cmdlet that returns something, but you don&#39;t want to use it and you don&#39;t want to output it. I found these two ways:

    Add-Item &gt; $null

    [void]Add-Item

    Add-Item | Out-Null

What do you use? Which is the better/cleaner approach? Why?


What&#39;s the better (cleaner) way to ignore output in PowerShell?

I want to write a function with `pl/pgsql`. 
I&#39;m using *PostgresEnterprise Manager v3* and using shell to make a function, but in the shell I must define return type. If I don&#39;t define the return type, I&#39;m not able to create a function.

How can create a function without return result, i.e a Function that creates a new table?

How to create function that returns nothing

    int fn();
    
    void whatever()
    {
        (void) fn();
    }

Is there any reason for casting an unused return value to void, or am I right in thinking it&#39;s a complete waste of time?



Why cast unused return values to void?

Due to the use of Generics in Java I ended up in having to implement a function having `Void` as return type:

    public Void doSomething() {
        //...
    }

and the compiler demands that I return *something*. For now I&#39;m just returning `null`, but I&#39;m wondering if that is good coding practice...

I&#39;m asking about **V**‌oid, not **v**‌oid. The class `Void`, **not** the reserved keyword `void`.

I&#39;ve also tried `Void.class`, `void`, `Void.TYPE`, `new Void()`, no return at all, but all that doesn&#39;t work at all. (For more or less obvious reasons) (See [this answer][1] for details)

* So what am I supposed to return if the return type of a function is `Void`? 
* What&#39;s the general use of the `Void` class?



  [1]: https://stackoverflow.com/questions/676663/what-do-i-return-if-the-return-type-of-a-method-is-void-not-void/881358#881358

What do I return if the return type of a method is Void? (Not void!)

In some C project, I have seen this code:

    static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
        (void)ud;
        (void)osize;
        /* some code not using `ud` or `osize` */
        return ptr;
    }

Do the two casts to void serve any purpose?

Why cast an unused function parameter value to void?

Imagine the following code:

    void DoThis()
    {
        if (!isValid) return;
    
        DoThat();
    }
    
    void DoThat() {
        Console.WriteLine(&quot;DoThat()&quot;);
    }

Is it OK to use a return inside a void method? Does it have any performance penalty? Or it would be better to write a code like this:

    void DoThis()
    {
        if (isValid)
        {
            DoThat();
        }
    }

Is it bad practice to use return inside a void method?

I am implementing a `ResponseHandler` for the apache HttpClient package, like so:

    new ResponseHandler&lt;int&gt;() {
        public int handleResponse(...) {
            // ... code ...
            return 0;
        }
    }

but I&#39;d like for the `handleResponse` function to return nothing, i.e. `void`. Is this possible? The following does not compile, since `void` is not a valid Java type:

    new ResponseHandler&lt;void&gt;() {
            public void handleResponse(...) {
                // ... code ...
            }
    }

I suppose I could replace `void` with `Void` to return a `Void` object, but that&#39;s not really what I want. **Question**: is it possible to organize this callback situation in such a way that I can return `void` from `handleResponse`?

Java generics void/Void types

The following Java code fails to compile:

    @FunctionalInterface
    private interface BiConsumer&lt;A, B&gt; {
        void accept(A a, B b);
    }
    
    private static void takeBiConsumer(BiConsumer&lt;String, String&gt; bc) { }
    
    public static void main(String[] args) {
        takeBiConsumer((String s1, String s2) -&gt; new String(&quot;hi&quot;)); // OK
        takeBiConsumer((String s1, String s2) -&gt; &quot;hi&quot;); // Error
    }

The compiler reports:

    Error:(31, 58) java: incompatible types: bad return type in lambda expression
        java.lang.String cannot be converted to void

The weird thing is that the line marked &quot;OK&quot; compiles fine, but the line marked &quot;Error&quot; fails. They seem essentially identical.

Why does this Java 8 lambda fail to compile?

I am reading a book ([Programming with POSIX Threads](https://smile.amazon.com/dp/0201633922) by Butenhof, 1997) that uses C, and I came across the following line:

```
(void)free(data);
```

Here, `data` is just a pointer to an allocated struct,

```
data = malloc(sizeof(my_struct_t));
```

Why is the result of `free` being cast to `void`?

From my understanding of C, this doesn&#39;t seem to make sense for two reasons:

 -  The free function already returns `void`
 -  The code is not using the return value (it&#39;s not even being assigned to a variable)

The book was written in 1997. Is this some sort of legacy thing?

The author mentions that the examples were run on Digital Unix 4.0d, but I still can&#39;t imagine a reason to ever cast the result of a function if you&#39;re not going to use that result.

Why cast free&#39;s return value to void?

I&#39;m looking at [a path finding tutorial](http://www.cokeandcode.com/main/tutorials/path-finding/) and I noticed a `return` statement inside a `void` method (class `PathTest`, line 126):

	if ((x &lt; 0) || (y &lt; 0) || (x &gt;= map.getWidthInTiles()) || (y &gt;= map.getHeightInTiles())) {
		return;
	}

I&#39;m a novice at Java. Can anyone tell me why it&#39;s there? As far as I knew, `return` inside a void method isn&#39;t allowed.

What does the return keyword do in a void method in Java?

I have a few static util methods in my project, some of them just pass or throw an exception. There are a lot of examples out there on how to mock a static method that has a return type other than void. But how can I mock a static method that returns void to just &quot;`doNothing()`&quot;?

The non-void version uses these lines of codes:

    @PrepareForTest(StaticResource.class)
...

    PowerMockito.mockStatic(StaticResource.class);

...

    Mockito.when(StaticResource.getResource(&quot;string&quot;)).thenReturn(&quot;string&quot;);


However if applied to a `StaticResources` that returns `void`, the compile will complain that `when(T)` is not applicable for void... 

Any ideas?

A workaround would probably be to just have all static methods return some `Boolean` for success but I dislike workarounds.

How do I mock a static method that returns void with PowerMock?

```html
&lt;a href=&quot;javascript:void(0)&quot; id=&quot;loginlink&quot;&gt;login&lt;/a&gt;
```

I&#39;ve seen such `href`s many times, but I don&#39;t know what exactly that means.

What does &quot;javascript:void(0)&quot; mean?

I&#39;ve just come across someone&#39;s C code that I&#39;m confused as to why it is compiling. There are two points I don&#39;t understand.

1.  The **function prototype** has no parameters compared to the actual function definition. 


2. The parameter in the **function definition** does not have a type.


----------


    #include &lt;stdio.h&gt;

    int func();

    int func(param)
    {
    	return param;
    }

    int main()
    {
    	int bla = func(10);    
    	printf(&quot;%d&quot;, bla);
    }



Why does this work? 
I have tested it in a couple of compilers, and it works fine.


Why does a function with no parameters (compared to the actual function definition) compile?

I&#39;ve seen some people using `void` operator in their code. I have also seen this in `href` attributes: `javascript:void(0)` which doesn&#39;t seem any better than `javascript:;`

So, what is the justification of using the `void` operator?

What is the point of void operator in JavaScript?

In API

&gt; &quot;The Void class is an uninstantiable placeholder class to hold a
&gt; reference to the Class object representing the Java keyword void.&quot;


1. What is &quot;uninstantiable&quot; place holder class? When will `java.lang.Void` be used? If the class  is &quot;uninstantiable&quot;, what use is it?
2. What is difference between `java.lang.Void` and `void`?

What is the difference between java.lang.Void and void?

Which is more correct way to return from function:

    void function() {
      // blah some code
    }

OR

    void function() {
      // blah some code
      return;
    }

___
Rationale for second way:

1. It expresses developer intentions more clearly.
2. It helps detecting function end at pre-compile time:

Suppose you have such scenario- you have bunch of functions and you must inject some code at the end of those functions. But for some reasons you don&#39;t want / or can&#39;t modify such huge amount of functions. What can you do about that ? `Return` &amp; `macro` comes into play, for example:

    #include&lt;stdio.h&gt;
    
    #define MAX_LINES 1000
    #define XCAT(a,b) a##b
    #define CAT(a,b) XCAT(a,b)
    #define return returns[__LINE__] = 1;\
            if (returns[__LINE__])\
               {printf(&quot;End of function on %d line.\n&quot;,__LINE__);}\
            int CAT(tmp,__LINE__); \
            if ((CAT(tmp,__LINE__)=returns[__LINE__], returns[__LINE__] = 0, CAT(tmp,__LINE__)))\
                  return
     
    static int returns[MAX_LINES];

    
    void function1(void) {
        return;
    }
    
    void function2(void) {
        return;
    }
    
    int main()
    {
        function1();
        function2();
    
        return 0;
    }




Returning from a void function

I have been running into a problem when trying to write a JUnit test case and am relatively new to Mockito.

I have a function of a class that I am mocking, this function happens to be of a void return type. When calling this function from my mocked class it is my understanding (and debugging experience) that it does NOT call the original function. In order to overcome this, I have attempted to use a &quot;when&quot; with a &quot;thenCallRealMethod()&quot;.

    when(instance.voidFunction()).thenCallRealMethod();

The &quot;voidFunction&quot; is full of logic that I do NOT want to fire. I have extracted these into when statements to avoid that. I have read that I should use the format of `doReturn().when().voidFunction()`, however doing this does not call the real method.

It was also my understanding that I could not use a Spy here, due to the fact that I do not want the `voidFunction()` called before the &quot;when&quot; statements. Any help is appreciated I apologize if this is a very easy solution as my understanding of mockito isn&#39;t very great despite reading quite a bit. Thanks!

Mockito - thenCallRealMethod() on void function

I&#39;m currently refactoring/tidying up some old C code used in a C++ project, and regularly see functions such as:

    int f(void)

which I would tend to write as:

    int f()

Is there any reason not to replace (void) with () throughout the codebase in order to improve consistency, or is there a subtle difference between the two that I am unaware of?

More specifically, if a virtual member function in C++ is described as:

    virtual int f(void)

and a derived class includes a member function:

    int f()

is this a valid override?  Additionally, am I likely to encounter any linker problems based on almost identical signatures?




Is f(void) deprecated in modern C and C++?

I have a method that returns void in a class that is a dependency of the class I want to test.

This class is huge and I&#39;m only using this single method from it.
I need to replace the implementation of this method for the test as I want it to do something different and I need to be able to access the parameters this method receives.

I cannot find a way of doing this in [EasyMock][1]. I think I know how to do it with [Mockito][2] by using [`doAnswer`][3] but I don&#39;t want to add another library unless absolutely necessary. 


  [1]: http://easymock.org/
  [2]: http://site.mockito.org/
  [3]: https://static.javadoc.io/org.mockito/mockito-core/2.7.5/org/mockito/Mockito.html#doAnswer(org.mockito.stubbing.Answer)

EasyMock: Void Methods

Is `void` a data type in the C programming language? If so, what type of values can it store? If we have `int`, `float`, `char`, etc., to store values, why is `void` needed? And what is the range of void?

Is void a data type in C?

Apparently, it is possible to declare a function returning `const void`:

    const void foo()
    {
    }

g++ seems to consider the `const` important, because the following code does not compile:

    #include &lt;type_traits&gt;

    static_assert(std::is_same&lt;void(), const void()&gt;::value, &quot;const matters&quot;);


So does `const void` have any practical significance?

What&#39;s the point of const void?

I have a class which defines two overloaded methods

    public void handle(Void e) 
    
    protected void handle() 

Obviously they are different, especially `handle(Void e)` is `public`.

&lt;br/&gt;
What&#39;s the difference between those two?  

How to call the first method? I am using `handle(null)` - is this correct?




What&#39;s the difference between Void and no parameter?

What does the following mean : 

    int main(void) {...} 

VS

    int main() {...}

?


I think that `int main() {...}` means that main doesn&#39;t receive any parameters (from command line) , however:

    int main(int argc, char *argv[])

does.

But, what does `int main(void) {...}`  mean? And, what does **void** stand for ?

I&#39;ve looked [here][1] but it&#39;s somehow a different question . 



  [1]: https://stackoverflow.com/questions/636829/difference-between-void-main-and-int-main


Difference between int main() and int main(void)?

I am not clear with the class `java.lang.Void` in Java. Can anybody elaborate in this with an example.


What is the need of Void class in Java

I have a function called:

    void initializeJSP(string Experiment)

And in my MyJSP.h file I have:

    2: void initializeJSP(string Experiment);

And when I compile I get this error:

&gt;MyJSP.h:2 error: variable or field initializeJSP declared void

Where is the problem?

  



All Void Solutions on Gang of Coders

Total of 40 Void Solutions