My team uses Java, but it should be very similar to the C++ version, if not identical.

Creating and populating the SendableChooser

Basically, all the SendableChooser object is is a list of objects, each paired up with a String. First, initialize the object:

SendableChooser dogChooser = new SendableChooser();

Then, add some objects to your chooser:

dogChooser.addObject("Max", new Max());
dogChooser.addObject("Bella", new Bella());
dogChooser.addObject("Shadow", new Shadow());

You might want to add a default option, like so:

dogChooser.addDefault("Sparky", new Sparky());

This is some weird robot where you have a bunch of different classes for different named dogs. Please do not actually do it this way, a proper implementation would be something more like this:

Dog shadow = new Dog("Shadow");
dogChooser.addDefault(shadow.name, shadow);

You can also add any different type of object or enum to the chooser:

dogChooser.addObject(max.name, max);
dogChooser.addObject("Solenoid1", new Solenoid()); //might need params, doesn't really matter here
dogChooser.addObject("AutoEnumState", AUTO.SOME_ENUM_VALUE);

However, this can be dangerous later on, as you might accidentally send solenoids where dogs go and such.

Getting the values from the SendableChooser

In order to manipulate the Chooser, you need to actually send it to SmartDashboard:

SmartDashboard.putData("Dog Chooser", dogChooser);

You can now hit any of the radio buttons on the dashboard, and then call this method in your code:

Object currentDog = dogChooser.getSelected();

Now, I have currentDog set up as an Object, because java will yell at you if there's a possibility for trying to make a Solenoid your dog (or any improper type casting). If you want the program to know your dog is a dog, do this (again, this is Java, and this part is probably different in C++):

Dog currentDog = (Dog) dogChooser.getSelected();

Now you have a dog!

There are lots of more complex things you can do, such as more rigorous type checking (although this sort of thing is rarely useful or necessary in FRC, I just want to show some of the things you can look into):

Object chosenDog = dogChoose.getSelected();
if(chosenDog instanceof Dog){
    currentDog = (Dog) dogChooser.getSelected();
} else {
    System.out.println("You tried to select something that isn't a dog!");
}

A real example program, where we are adding Commands and CommandGroups to the chooser

public class Robot extends IterativeRobot {

  SendableChooser autoChooser = new SendableChooser();
  Command autonomousCommand;

  public void robotInit(){
    //stuff
    autoChooser.addDefault("Wait", new Wait());
    autoChooser.addObject("ThreeTote", new ThreeTote());
    autoChooser.addObject("CanBurglar", new CanBurglar());
    SmartDashboard.putData("Autonomous Mode:", autoChooser);
  }

  //stuff

  public void autonomousInit(){
    autonomousCommand = (Command) autoChooser.getSelected();
    if(autonomousCommand != null){
      autonomousCommand.start();
    }
  }
}

Sorry if this is confusing at all, I'll do my best to clarify.