I am using the Direct2D API to draw some graphics for my program. I have a function that I call every time the Window redraws that draws the frame. I can't hardcode every object to be drawn into the function, if I want it to be dynamic. What is the common practice for solving this?

Again, polymorphism comes to the rescue. It is extremely typical, in fact I don't remember ever seeing any other solution to this, to use a "renderable" interface class and make all your objects that need to be rendered as derived from that interface:

//interface for all renderable objects
class Renderable {
  public:
    virtual void render() = 0; //pure virtual render method.
};

//say you have a class Square, which is derived from another class Polygon, derive it also from interface class Renderable
class Square : public Polygon, public Renderable {
  ...
  public 
    ...
    void render() { ..put rendering code here.. };
}; 

//Say you have a Canvas class that holds all things that are rendered to the screen or window:
class Canvas {
  private:
    std::vector<Renderable*> Objects; //hold the list of renderable objects.
  public:
    void render() { //Canvas has its own render function, of course.
      ... initialize screen (like clear buffer, load camera, etc.) ...
      for(int i=0;i<Objects.size();++i)
        if(Objects[i])
          Objects[i]->render(); //render all the objects.
      ... finish off ...
    };
};

I have programmed several game engines and other visualization stuff, and that's basically the way to go, most of the time (at least in simple cases).