You check that a value is defined in the mapping by checking it is not zero.

If an explicit setting of zero has meaning for your application, you need auxiliary data (or structure) to track when a value of zero has been explicitly set.

A lightweight approach would be to add a bool property to the struct (say named initialized), and to set it to true when the zero is explicitly set. As all bools are false (0) by default, you can check against the value true.

Alternatively, check that each member of the struct is zero. If a member is a string, cast it to bytes and then check its length is zero.

For an example see How to test if a struct state variable is set

Another data structure or mapping may be needed depending on the application.

Here is a related example on using a pair to check the meaning of zero:

contract C {
    uint[] counters;
    function getCounter(uint index)
        returns (uint counter, bool error) {
            if (index >= counters.length) return (0, true);
            else return (counters[index], false);
        }
    function checkCounter(uint index) {
        var (counter, error) = getCounter(index);
        if (error) { ... }
        else { ... }
    }
}

Some issues:

1. The compiler does not yet support copying memory struct arrays to storage, so things[id] = thing; will fail.

2. Thing thing; will initialize thing to a Thing with thing.items set to an empty array, so there's no need to use the constructor at all.

3. Since all elements of mappings come pre-initialized to their "zero" values, there's no need to create a Thing in memory, then copy it to the mapping. Just assign values to the mapping's properties.

For example, this is the code I would use, with some added fields to better illustrate the concept:

contract Foo {
    mapping (bytes32 => Thing) things;

    struct Thing {
        Item[] items;
        uint _bar;
    }

    struct Item {
        uint number;
    }

    function Foo(bytes32 id, uint bar) {
        things[id]._bar = bar;
    }
}

This demonstrates how mapping elements are pre-initialized. things[id].items will return an empty Item[].

In addition, you can create an uninitialized Thing, and all of it's fields will default to zero (ore empty, false, etc.)

Honestly, I don't know how solve this problem. I changed store a little bit, now it works, maybe it will be helpful for you

P.s in 0.4.25 version you can return all post comments, but in 0.5.1 I assume that its not support as default yet

pragma solidity ^0.5.1;

contract Board {

    //storage
    uint256 public postAmount = 0;
    mapping(uint256 => Post) public posts;

    struct Comment {
        address author;
        string comment;
    }

    struct Post {
        address author;
        string title;
        string content;
        Comment[] comments;
    }

    //add-post
    function addPost(address _author, string memory _title, string memory _content, string memory _comment) public {
        Post storage post = posts[postAmount];
        post.author = _author;
        post.title = _title;
        post.content = _content;

        bytes memory tempEmptyString = bytes(_comment);
        if (tempEmptyString.length != 0) { // check if comment exists
            post.comments.push(Comment({
                 author: _author,
                 comment: _comment
            }));
            postAmount++;
        }
    }

    function getComment(uint256 _postIndex, uint256 _commentIndex) public view returns(string memory) {
        Post memory post = posts[_postIndex];
        return post.comments[_commentIndex].comment;
    }
}

How about:

Cart storage c = carts[msg.sender];
c.total = 0;
//whatever else you need to store in the newly created cart;

In solidity, all values in a mapping are virtually initialized, so you can straight access them and their members.

The following will work:

contract Test {
    struct Object {
        uint a;
        string b;
        string[] c;
        mapping(uint => uint) d;
    }

    Object field;

    function Test() {
        field = Object({
            a: 1,
            b: "abc",
            c: new string
        });
    }
}

There is no need to initialize storage arrays in Solidity. Only memory arrays has to be initialized before usage.

So in your case, no need to initialize x inside Bar as long as you are not assigning a value to one of the x indexes inside your foobar. Actually, making initialization in your code will consume gas for no reason.

The following code works well for your case:

function foobar(address a) public {
    Bar memory b;
    b.owner = a;
    //When 'b' is pushed to 'bars' array:
    // (1) 'b' will be converted from memory to storage.
    // (2) And 'x' inside it will be initialized automatically.
    bars.push(b); 
}

However, if you need to access x and push some value you can use push:

function foobar2(address a, uint x0) public {
    Bar memory b;
    b.owner = a;
    bars.push(b);
    //Trying: b.x[0] = x0; will generate error. Since, b.x is a memory array that is not initialized!
    bars[bars.length - 1].x.push(x0); //This will work fine!
}

Actually, you can still initialize your memory array, as an empty one, as follow:

function foobar3(address a) public {
    Bar memory b = Bar(a, new uint); //Thanks to "James Duffy" for his answer.
    bars.push(b);
}

Last thing to mention is that: If you have multi values, that you need to insert to your x array, then you can do this as follow:

function foobar4(address a, uint[] _x) public {
    Bar memory b = Bar(a, _x);
    bars.push(b);
}

Or as follow. But, this will consume more gas:

function foobar5(address a, uint[] _x) public {
    Bar memory b;
    b.owner = a;
    bars.push(b);

    Bar storage c = bars[bars.length - 1]; // Get the newly added instance of the storage struct
    for (uint i = 0; i < _x.length; i++) {
        c.x.push(_x[i]);
  }

Check full code at the nice EthFiddler: https://ethfiddle.com/fQI6Khgz3E

Try this - the 0 in the braces means you're initializing a dynamic array of size 0.

Client newClient = Client(true, 0x7465737400000000000000000000000000000000000000000000000000000000, new address);