Store and passing std::function's - by value or by reference?

Question

I'm having trouble knowing when to pass/store std::function objects by value or reference, or if I need to use move semantics somehow. I have a struct that stores two std::function objects:

struct Control{
    char key;
    std::function<void()> press;
    std::function<void()> release;
    Control(char key, std::function<void()> press, std::function<void()> release):
        key(key),press(press),release(release){}
}

I also have a class that contains a vector of these structs, and I'd like to initialize it in a function resembling this one:

void Screen::init(Player& player){

    this->controls.push_back(Control(
        'W',
        [&player](){player.go(UP);},
        [&player](){player.stop(UP);}));

}

I'd like to be able to pass lambda expressions directly to the Control constructor, and eventually do this repeatedly:

void Screen::update(){
    foreach (auto control : controls){
        if(...) 
            control.press();
        else if (...) 
            control.release();
    }
}

I've encountered a lot of errors and crashes trying to implement this idea, so I need to know

• Should the std::function's be stored by (const?) reference, or by value, taking into account they capture a reference?
• Should they be passed to the Control constructor by (const?) reference, or value, (or moved, somehow)?
• Is it alright to store the Controls by value in a vector this way, or will I need to use an alternative (unique_ptr<Control>, etc.)?
• when I loop through the controls vector, should I be accessing them by value, or by reference?

Assume that the Player& object is always in scope for Screen::update().