Working with structure arrays in solidity

Question

I have the following contract code example:

contract C {

    struct A {
        uint256 a;
        uint256 b;
    }

    struct B {
        A ax;
        uint256 c;
    }

    struct C {
        string name;
        B[] bs;
    }

    function init() {
        C memory c;
        B memory b;
        A memory a;

        a.a = 10;
        a.b = 20;

        b.ax = a;
        b.c = 30;

        c.name = "Test test test";
        c.bs[0] = b;
    }
}

Why can't I use push for the last statement

 c.bs[0] = b;

:

c.bs.push(b);

It throws the following error:

Untitled:30:9: Error: Member "push" is not available in struct B memory[] memory outside of storage.
        c.bs.push(b);
        ^-------^

but bs is an array of structures.

Answer 1

Push is available only on storage arrays, that is member/ state variables and not in memory arrays, that is local variables:

push: Dynamic storage arrays and bytes (not string) have a member function called push that can be used to append an element at the end of the array. The function returns the new length.

http://solidity.readthedocs.io/en/latest/types.html

Answer 2

Explaining further what atc mentioned in their comment,

Fixed vs variable length

• Memory arrays have fixed length, which means their length cannot be modified after it is initialized. Since push() appends a new element at the end of the array, it is not available for memory arrays.

• Storage arrays, on the other hand, can have variable length. Yet, they're more expensive. Do you have to use storage arrays for your use case? Maybe not; keep reading.

Static vs dynamic length

• Static-length arrays are initialized with a length defined at compile time, which is specified inside the array's square brackets. If you want to initialize them with a length that's not defined at compile time, you'll get an error:

function bar(uint baz) public {
    uint[7] memory foo1; // this is fine
    uint[7] storage foo2; // this is fine
    uint[baz] memory foo3; // this throws a compile-time error
    uint[baz] storage foo4; // this throws a compile-time error
}

As you can see, this applies for both memory and storage arrays.

• Dynamic-length arrays are initialized with a length defined at runtime, which is specified by means of the new keyword and written inside parentheses after the array's square brackets:

function bar(uint baz) public {
    uint[] memory foo1 = new uint[](7); // this is fine
    uint[] storage foo2 = new uint[](7); // this is fine
    uint[] memory foo3 = new uint[](baz); // this is fine
    uint[] storage foo4 = new uint[](baz); // this is fine
}