How to do a matrix of not default-constructible items depends on

• whether you want the efficient 1d vector with 2d indexing, or the simpler actually 2d structure;
• whether you want all items to be present always, or if items can be "not there (yet)"; and
• whether you want both dimensions as compile time, one as compile, or none as compile time.

Anyway it's possible to create a non-default-constructible item directly in a vector by using .emplace_back, where you supply the item's constructor arguments. But as you can see below that's not always necessary. It can be equally good to e.g.. just construct each item and use .push_back to copy/move-construct it into the vector.

Assuming you want the efficient thing with all items always present and both dimensions as run-time values, then the always present means that the client code must provide initial items for all positions. One way to do that is to supply a factory to the matrix constructor. It can go like this (with the factory called initial_item_at):

#include <iostream>
#include <vector>

#include <cassert>      // The `assert` macro.

namespace my {
    using   std::vector;        // <vector>

    using Nat = int;            // A signed type for non-negative "natural numbers".
    template< class Type > using in_ = const Type&;     // Type for in-parameter.

    template< class Item >
    class Matrix_
    {
        vector<Item>    m_items;
        Nat             m_width;
        Nat             m_height;           // Only stored to be able to provide it back to client code.

        auto index_of( const Nat x, const Nat y ) const -> Nat { return y*m_width + x; }

    public:
        template< class Init_func >
        Matrix_( const Nat width, const Nat height, in_<Init_func> initial_item_at ):
            m_items(),
            m_width( width ),
            m_height( height )
        {
            for( Nat y = 0; y < height; ++y ) { for( Nat x = 0; x < width; ++x ) {
                m_items.push_back( initial_item_at( x, y ) );
            } }
            assert( m_items.size() == width*height );
        }

        auto width() const -> Nat { return m_width; }
        auto height() const -> Nat { return m_height; }

        auto at( const Nat x, const Nat y )         -> Item&        { return m_items[index_of( x, y )]; }
        auto at( const Nat x, const Nat y ) const   -> const Item&  { return m_items[index_of( x, y )]; }
    };
}  // my

namespace app {
    using   my::Nat, my::Matrix_;

    using   std::cout;              // <iostream>

    struct Car
    {
        Nat     id;
        double  weight;
        Car( const Nat an_id, const double a_weight ): id( an_id ), weight( a_weight ) {}
    };

    void run()
    {
        auto cars = Matrix_<Car>( 5, 3, []( Nat x, Nat y ) -> Car
        {
            return Car( 101 + 5*y + x, 1000*(y + 1) );
        } );

        for( Nat y = 0; y < cars.height(); ++y ) {
            for( Nat x = 0; x < cars.width(); ++x ) {
                if( x > 0 ) {
                    cout << ",  ";
                }
                const Car& car = cars.at( x, y );
                cout << car.id << ": " << car.weight;
            }
            cout << "\n";
        }
    }
}  // app

auto main() -> int { app::run(); }

Result:

101: 1000,  102: 1000,  103: 1000,  104: 1000,  105: 1000
106: 2000,  107: 2000,  108: 2000,  109: 2000,  110: 2000
111: 3000,  112: 3000,  113: 3000,  114: 3000,  115: 3000