You can see the entire program greedy.cpp here or view it in the standard distribution.

 
#include <ilsched/iloscheduler.h>
 
ILOSTLBEGIN
 
#if defined(ILO_SDXLOUTPUT)
#include "sdxloutput.h"
#endif
 
///////////////////////////////////////////////////////////////////////////////
//
// PROBLEM DEFINITION
//
///////////////////////////////////////////////////////////////////////////////
 
 
IloModel DefineModel(IloEnv& env, IloNumVar& makespan)
{
  IloModel model(env);
 
  /* CREATE THE ACTIVITIES. */
  IloActivity masonry(env,   7, 0, "masonry   ");
  IloActivity carpentry(env, 3, 0, "carpentry ");
  IloActivity plumbing(env,  8, 0, "plumbing  ");
  IloActivity ceiling(env,   3, 0, "ceiling   ");
  IloActivity roofing(env,   1, 0, "roofing   ");
  IloActivity painting(env,  2, 0, "painting  ");
  IloActivity windows(env,   1, 0, "windows   ");
  IloActivity facade(env,    2, 0, "facade    ");
  IloActivity garden(env,    1, 0, "garden    ");
  IloActivity moving(env,    1, 0, "moving    ");
  
  /* ADD THE TEMPORAL CONSTRAINTS. */
  model.add(carpentry.startsAfterEnd(masonry));
  model.add(plumbing.startsAfterEnd(masonry));
  model.add(ceiling.startsAfterEnd(masonry));
  model.add(roofing.startsAfterEnd(carpentry));
  model.add(painting.startsAfterEnd(ceiling));
  model.add(windows.startsAfterEnd(roofing));
  model.add(facade.startsAfterEnd(roofing));
  model.add(facade.startsAfterEnd(plumbing));
  model.add(garden.startsAfterEnd(roofing));
  model.add(garden.startsAfterEnd(plumbing));
  model.add(moving.startsAfterEnd(windows));
  model.add(moving.startsAfterEnd(facade));
  model.add(moving.startsAfterEnd(garden));
  model.add(moving.startsAfterEnd(painting));
 
  
  /* CREATE THE RESOURCE. */
  IloUnaryResource worker(env);
 
  /* ADD THE RESOURCE CONSTRAINTS. */
  model.add(masonry.requires(worker));
  model.add(carpentry.requires(worker));
  model.add(plumbing.requires(worker));
  model.add(ceiling.requires(worker));
  model.add(roofing.requires(worker));
  model.add(painting.requires(worker));
  model.add(windows.requires(worker));
  model.add(facade.requires(worker));
  model.add(garden.requires(worker));
  model.add(moving.requires(worker));
   
  /* SET THE MAKESPAN VARIABLE. */
  makespan = IloNumVar(env, 0, IloInfinity, ILOINT);
  model.add(moving.endsAt(makespan)); 
 
  /* SET THE OBJECTIVE */
  model.add(IloMinimize(env, makespan));
 
  return model;
}
 
IlcBool 
SelFirstActStartMax(IlcActivity& selection, const IlcScheduler& scheduler) 
{
 
  /* IF A NOT BOUNDED ACTIVITY EXISTS IN THE SCHEDULE, RETURN ILCTRUE 
     AND SET SELECTION AS THE ACTIVITY WITH THE MINIMAL LATEST START TIME. */
  IlcInt startmax = IlcIntMax;
  IlcBool selected = IlcFalse;
  for (IlcActivityIterator iterator(scheduler); 
       iterator.ok();
       ++iterator)
  {
    IlcActivity activity = *iterator;
    if (!activity.getStartVariable().isBound() 
        && (activity.getStartMax() <= startmax))
    {
      startmax = activity.getStartMax();
      selection = activity;
      selected = IlcTrue;
    }
  }
  return selected;
} 
 
ILCGOAL0(SolveIlc) {
  IloSolver solver = getSolver();
  IlcActivity chosenActivity;
  if (SelFirstActStartMax(chosenActivity, IlcScheduler(solver))) {
    chosenActivity.setStartTime(chosenActivity.getStartMin());
    return this;
  }
  else 
    return 0;
}
 
ILOCPGOALWRAPPER0(Solve, solver) {
  return SolveIlc(solver);
}
 
///////////////////////////////////////////////////////////////////////////////
//
// PRINTING OF SOLUTIONS
//
///////////////////////////////////////////////////////////////////////////////
 
void PrintSolution(const IloSolver& solver)
{
  IlcScheduler scheduler(solver);
  IloEnv env = solver.getEnv();
  for(IloIterator<IloActivity> act(env);
      act.ok();
      ++act)
    env.out() << scheduler.getActivity(*act) << endl;
  solver.printInformation();
}
 
///////////////////////////////////////////////////////////////////////////////
//
// MAIN FUNCTION
//
///////////////////////////////////////////////////////////////////////////////
 
int main()
{
  try {
    
    IloEnv env;
    IloNumVar makespan;
    IloModel model = DefineModel(env, makespan);
 
    IloSolver solver(model);
    IloGoal goal = Solve(env);    
 
    if (solver.solve(goal)) {
      PrintSolution(solver);
#if defined(ILO_SDXLOUTPUT)
      IloSDXLOutput output(env);
      ofstream outFile("greedy.xml");
      output.write(IlcScheduler(solver), outFile, solver.getIntVar(makespan));
      outFile.close();
#endif
    }
    else
      solver.out() << "No Solution" << endl;
 
    env.end();
    
  } catch (IloException& exc) {
    cout << exc << endl;
  }
  return 0;
}
 
///////////////////////////////////////////////////////////////////////////////
//
// RESULTS
//
///////////////////////////////////////////////////////////////////////////////
 
/*
masonry    [0 -- 7 --> 7]
carpentry  [15 -- 3 --> 18]
plumbing   [7 -- 8 --> 15]
ceiling    [18 -- 3 --> 21]
roofing    [21 -- 1 --> 22]
painting   [22 -- 2 --> 24]
windows    [26 -- 1 --> 27]
facade     [24 -- 2 --> 26]
garden     [27 -- 1 --> 28]
moving     [28 -- 1 --> 29]
*/
 

The start and end times of all activities are fixed in this example.