Is this visitor implementation correct?

Question

I am implementing a visitor in order to use it with the boost variant library. I want to know if is correct to specialize boost::static_visitor<> with a const reference type.

Note my question here is the following:

There are any problem specializing boost::static_visitor<> to boost::static_visitor<const T&> ?

template<typename T>
struct my_visitor : public boost::static_visitor<const T&> {

    template<typename U> const T& operator()(U& u) const {
        // some code here .....
        return X<U>::get_some_t(); // finally return some T.
    }
};

I'm having a hard time understanding your question even reading the question a couple times. Could you provide a more complete example about what you're trying to do? — Mark B, Nov 06 '14 at 16:20
@MarkB is very simple, I am implementing a visitor in a more complex scenario that this I showed up in the question, and I am getting some weird errors. So in order to discard some possibilities I want to know if there is any problem specializing the static_visitor template with const T&. I am expecting that some expert give me the answer: No that shouldn't give you any problem. Or maybe: Yes, when you do that, occurs (...). Thanks for the interest in advance. — Eric Javier Hernandez Saura, Nov 06 '14 at 16:32

sehe · Accepted Answer · 2014-11-06T20:58:15.143

There is no problem as long as you don't return a reference to a local/temporary.

Also, be sure to check the validity of the reference over time (it ends when the variant object is destructed, which is when the variant itself is destructed, or (!) when it is reinitialized).

Background and explanation

A variant contains an object of the "current" element type, and you can reference into that object perfectly fine. As long as the variant is not reinitialized to another element type (in which case the reference is "just" dangling, exactly like it would if the lifetime of the referred-to object had ended).

So if get_somet_t() returns a T& or T const& (or something with a suitable implicit conversion) there is no problem.

In a simpler setting let me demonstrate valid options:

variant<int, std::string> v1 = 42;

int& i1 = get<int>(v1); // returns by ref, valid
i1 *= 2;

// now v1 contains the updated integer value 84

Likewise, you can even make variants of /just references/:

std::string s = "hello";
int answer = 42;

variant<int&, std::string&> v2(s);
get<std::string&>(v2) += " world"; // now s contains "hello world"

variant<int&, std::string&> v3(answer);
get<int&>(v3) *= 2; // now `answer` contains 84

See it all Live On Coliru

Demonstration

Put yet another way, the following is fine:

struct A { std::string a_property; };
struct B { std::string b_field;    };

struct select_member : static_visitor<std::string&> {
    std::string& operator()(A& a) const { return a.a_property; }
    std::string& operator()(B& b) const { return b.b_field;    }
};

int main()
{
    variant<A,B> v = A { "some string" };

    apply_visitor(select_member(), v) += " suffix";

    std::cout << get<A>(v).a_property << "\n"; // prints "some string suffix"
}

See it Live On Coliru as well.

Added a demonstration that closely resembles your original case, though even with non-const references under **Demonstration** — sehe, Nov 06 '14 at 20:59

score 0 · Answer 2 · answered Jul 11 '22 at 17:25

What about this, is this neat?

public interface Worker {
  <T> T accept( Visitor<T> visitor);
}

public class Developer implements Worker { 
  @Override
  public <T> T accept( Visitor<T> visitor ) {
    return visitor.workAsDeveloper( this );
  }
}

public class Manager implements Worker {
  @Override
  public <T> T accept( Visitor<T> visitor ) {
    return visitor.manageAsManager( this );
  }
}

public class Boss implements Worker {  
  @Override
  public <T> T accept( Visitor<T> visitor ) {
    return visitor.planLikeBoss( this );
  }
}

public interface Visitor<T> {
  T workAsDeveloper( Developer type );
  T manageAsManager( Manager type );
  T planLikeBoss( Boss type );
}

public class VisitorImpl implements Visitor<String> {
  
  @Override
  public String workAsDeveloper( Developer type ) {
    return "Working hard as a Developer";
  }
  
  @Override
  public String manageAsManager( Manager type ) {
    return "Managing smoothly as a Manager";
  }
  
  @Override
  public String planLikeBoss( Boss type ) {
    return "Planning like a Boss";
  }
}

public class App {
  Visitor<String> visitor;
  
  public App( Visitor<String> visitor ) {
    this.visitor = visitor;
  }
  
  public static void main( String[] args ) {
    // Given
    App app = new App( new VisitorImpl() );
    
    Developer developer = new Developer();
    Manager manager = new Manager();
    Boss boss = new Boss();
    
    // When
    app.run( developer );
    app.run( manager );
    app.run( boss );
  }
  
  void run( Worker worker ) {
    System.out.println( worker.accept( visitor ) );
  }
}

Is this visitor implementation correct?

2 Answers2

Background and explanation

Demonstration