Correct way of inserting std::optional<T> into std::vector<T>

Question

I have a class T, it looks like this:

class T {
  uint64_t id;
  std::string description;
  char status;
  uint64_t createdAt;
  uint64_t updatedAt;

T(uint64_t c_id, std::string_view c_description, char c_status, uint64_t c_createdAt, uint64_t c_updatedAt) :
    id(c_id),
    description(c_description),
    status(c_status),
    createdAt(c_createdAt),
    updatedAt(c_updatedAt) {}

T(T&& other) :
    id(other.id),
    description(std::move(other.description)),
    status(other.status),
    createdAt(other.createdAt),
    updatedAt(other.updatedAt) {}
  // member functions
};

At some point, I need to append an optional into a vector. What is the best way between these options (or are there other options)?

std::optional<T> opt = myFunction();
std::vector<T> tasks;
if(opt.has_value()) {
  tasks.push_back(*opt);
  tasks.push_back(opt.value());
  tasks.push_back(std::move(*opt));

  tasks.emplace_back(*opt);
  tasks.emplace_back(opt.value());
  tasks.emplace_back(std::move(*opt));
}

"best" by which metric? Also, what should happen if the optional is empty? — Botje
– Botje, Commented Mar 25 at 9:16
Are you sure the optional is non-empty? Also important but omitted: does T have a move constructor? You left out all member functions, including the most important one for this question. — MSalters
– MSalters, Commented Mar 25 at 9:17
The snippet is just a recreation of my program, so I didn't add the check in there. I've also added the relevant constructors of T. — bramar2
– bramar2, Commented Mar 25 at 9:50
Offtopic: Be aware that T symbol name is usually used as template parameter. So when you use this as actual class name this is vary confusing for may developers. You should use Foo or Bar. — Marek R
– Marek R, Commented Mar 25 at 11:38

Caleth · Accepted Answer · 2025-03-25 10:28:13Z

9

In C++26, the simplest way to copy-insert the contents of opt is

std::optional<T> opt = myFunction();
std::vector<T> tasks;
tasks.append_range(opt);

And the simplest way to move-insert the contents of opt is

std::optional<T> opt = myFunction();
std::vector<T> tasks;
tasks.append_range(opt | std::views::as_rvalue);

edited Mar 25 at 10:28

answered Mar 25 at 9:32

Caleth

66k2 gold badges53 silver badges101 bronze badges

Sign up to request clarification or add additional context in comments.

9 Comments

Dominik Kaszewski Mar 25 at 10:00

How is std::ranges::move(opt, std::back_inserter(tasks)); simpler than tasks.push_back(std::move(*opt));?

Caleth Mar 25 at 10:00

@DominikKaszewski it doesn't assume opt has a value, under pain of undefined behaviour

Caleth Mar 25 at 10:13

@DominikKaszewski It wasn't when I wrote this answer. The point is that checking isn't desirable.

Jarod42 Mar 25 at 10:19

So, std::optional<T> is viewed as a range of 0 or 1 element.

Caleth Mar 25 at 10:23

@Jarod42 yes, which is great for things like this, or range | transform(func_returining_optional) | join

|

Ahmed AEK · Accepted Answer · 2025-03-25 11:12:11Z

// copies optional content into vector, optional unchanged
// undefined behavior if optional was originally empty
tasks.push_back(*opt); 

// copies optional content into vector, optional unchanged
// throws std::bad_optional_access if optional is empty
tasks.push_back(opt.value());

// moves the optional content into vector, opt std::string member is now empty
// undefined behavior if optional was originally empty
tasks.push_back(std::move(*opt));

// moves the optional content into vector, opt std::string member is now empty
// throws std::bad_optional_access if optional is empty
tasks.push_back(std::move(opt.value()));

the cheapest (generating the least amount of assembly instructions) would be

if (opt) // get rid of UB in operator*
{
  tasks.push_back(std::move(*opt)); // move the contents of opt into tasks
}
// bonus: same syntax as a pointer!

there is no difference between push_back and emplace_back in this context. emplace_back is only useful when the type of the argument is different than the type of the container and you want to have a conversion. push_back will do a conversion then a move, whereas emplace_back will just do a conversion. Don't abuse emplace_back as it does explicit conversions implicitly.

GDGiantDwarf · Accepted Answer · 2025-03-25 09:54:30Z

-1

Depending on your need, it might also be simpler to just hold a list of optionals

std::optional<T> opt = myFunction();
std::vector<std::optional<T>> maybeTasks;
maybeTasks.push_back(opt);

and worry later about wether they exist, or if all tasks are created and then handled separately:

std::vector<T> taskList;
for (auto it : maybeTasks) {
    if(it.has_value()) {
        taskList.push_back(it.value());
    }
}

answered Mar 25 at 9:54

GDGiantDwarf

94 bronze badges

3 Comments

Darkproduct Mar 25 at 12:17

This just costs memory, reduces cache locality and performance. The check is also very simple and should be done before inserting. It's only a matter of how to insert.

GDGiantDwarf Mar 25 at 18:35

It is definitely not code made for performance. It is however pretty readable and beginner-friendly, and depending on the application, sometimes good enough in my opinion.

Darkproduct Mar 26 at 11:24

But still you are doing the exact same thing just in the wrong order. It costs you nothing to do the if has_value before inserting. It is objectively better with no downsides.

Collectives™ on Stack Overflow

Correct way of inserting std::optional<T> into std::vector<T>

3 Answers 3

9 Comments

Comments

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

9 Comments

Comments

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related