freeze when returning a component from a function

[uyha-kwz]

I want to have a function that returns a component, I have the function defined as follows:

template <typename T>
auto number(T &source) -> ftxui::Component {
  using namespace ftxui;

  auto decrease  = Button("-", [&] { --source; });
  auto increase  = Button("+", [&] { ++source; });
  auto container = Container::Horizontal({decrease, increase});
  return Renderer(container, [&] {
    return hbox({
        decrease->Render(),
        text(fmt::format("{}", source)) | center,
        increase->Render(),
    });
  });
}

then I have the following snippet in main

int main() {
  using namespace ftxui;

  auto level    = std::uint8_t{0};
  auto renderer = number(level);
  auto screen   = ScreenInteractive::Fullscreen();

  screen.Loop(renderer);
}

but then the application just freezes when I run it, what am I doing wrong here?

[ArthurSonzogni]

Hello @uyha-kwz

Your lambda captures decrease and increase declared from the stack by reference. It is not valid using them after the end of the function.

Your binary suffers from undefined behavior / memory safety issues.

Capture the Component (std::shared_ptr) by value in the lambda. (Not recommanded)

template <typename T>
auto number(T &source) -> ftxui::Component {
  using namespace ftxui;

  auto decrease  = Button("-", [&] { --source; });
  auto increase  = Button("+", [&] { ++source; });
  auto container = Container::Horizontal({decrease, increase});
  return Renderer(container, [decrease, increase, &source] {
    return hbox({
        decrease->Render(),
        text(std::to_string(source)) | center,
        increase->Render(),
    });
  });
}

Implement your own ftxui::ComponentBase and store them in.

template <typename T>
auto number(T& source) -> ftxui::Component {
  using namespace ftxui;

  class Number : public ComponentBase {
   private:
    T& source_;
    Component decrease_ = Button("-", [&] { --source_; });
    Component increase_ = Button("+", [&] { ++source_; });
    Component container_ = Container::Horizontal({
        decrease_,
        increase_,
    });

   public:
    Number(T& source) : source_(source) { Add(container_); }

    Element Render() override {
      return hbox({
          decrease_->Render(),
          text(std::to_string(source_)) | center,
          increase_->Render(),
      });
    }
  };

  return Make<Number>(source);
}

[uyha-kwz]

oh, they are being passed as references, I thought they were being copied. Thanks a lot for the explanation. This is when I wish C++ has a more explicit syntax for passing reference like Rust.

[ArthurSonzogni]

You can pass:

• by copy using [argument]
• by reference using [&argument]
• by move using [argument = std::move(x)]

Then the [&] and [=] shorthands means capturing everything else by reference, and by copy respectively.

[uyha-kwz]

ok, that makes sense. Can you elaborate why capturing by value is not recommended? As far as I can tell, it's similar to the implementation by hand.

[ArthurSonzogni]

Capturing by value is great in general.

Here, I am not recommanding it, because when the object to copy is a std::shared_ptr, it might be tricky to understand we copy the pointer and not object.

You can still use it if you want and understand what happens.

[uyha-kwz]

thank you very much for the answers.