A full adder is usually depicted like this, with 1-bit inputs, sum, and carry:

A simple quantum circuit for the corresponding truth table could be drawn like this:

In my own code base, this translates into this code:

  psi = ops.Cnot(0, 3)(psi, 0)
  psi = ops.Cnot(1, 3)(psi, 1)
  psi = ops.ControlledU(0, 1, ops.Cnot(1, 4))(psi, 0)
  psi = ops.ControlledU(0, 2, ops.Cnot(2, 4))(psi, 0)
  psi = ops.ControlledU(1, 2, ops.Cnot(2, 4))(psi, 1)
  psi = ops.Cnot(2, 3)(psi, 2)
  return psi

This code applies the gates one after the other. So in order to obtain a single big matrix you have to multiply all the gates together in reverse order and properly pad them to 5 qubits, as in the following (assuming I didn't make a mistake here), where * denotes the Kronecker product and @ is matrix multiply:

  M = ((ops.Identity(2) * ops.Cnot(2, 3) * ops.Identity(1)) @
       (ops.Identity(1) * ops.ControlledU(1, 2, ops.Cnot(2, 4))) @
       (ops.ControlledU(0, 2, ops.Cnot(2, 4))) @
       (ops.ControlledU(0, 1, ops.Cnot(1, 4))) @
       (ops.Identity(1) * ops.Cnot(1, 3) * ops.Identity(1)) @
       (ops.Cnot(0, 3) * ops.Identity(1)) )

The resulting matrix is $2^5 \times 2^4$ and looks something like:

Operator for 5-qubit state space. Tensor:
[[1.+0.j 0.+0.j 0.+0.j ... 0.+0.j 0.+0.j 0.+0.j]
 [0.+0.j 1.+0.j 0.+0.j ... 0.+0.j 0.+0.j 0.+0.j]
 [0.+0.j 0.+0.j 1.+0.j ... 0.+0.j 0.+0.j 0.+0.j]
 ...
 [0.+0.j 0.+0.j 0.+0.j ... 0.+0.j 1.+0.j 0.+0.j]
 [0.+0.j 0.+0.j 0.+0.j ... 1.+0.j 0.+0.j 0.+0.j]
 [0.+0.j 0.+0.j 0.+0.j ... 0.+0.j 0.+0.j 0.+0.j]]

This should be relatively simple to achieve in other infrastructures, such as Qiskit. Hope this helps.