This is an example of using a QuantLib term structure for pricing a simple swap.
#include <ql/qldefines.hpp>
#ifdef BOOST_MSVC
#  include <ql/auto_link.hpp>
#endif
#include <ql/termstructures/yield/piecewiseyieldcurve.hpp>
#include <ql/termstructures/yield/ratehelpers.hpp>
#include <ql/pricingengines/swap/discountingswapengine.hpp>
#include <ql/indexes/ibor/euribor.hpp>
#include <ql/time/imm.hpp>
#include <ql/time/calendars/target.hpp>
#include <ql/time/daycounters/actual360.hpp>
#include <ql/time/daycounters/thirty360.hpp>
#include <ql/time/daycounters/actualactual.hpp>
#include <boost/timer.hpp>
#include <iostream>
#include <iomanip>
#if defined(QL_ENABLE_SESSIONS)
}
#endif
int main(int, char* []) {
    try {
        boost::timer timer;
        std::cout << std::endl;
        
        Date settlementDate(22, September, 2004);
         
        settlementDate = calendar.
adjust(settlementDate);
        Date todaysDate = calendar.
advance(settlementDate, -fixingDays, Days);
         
        std::cout << 
"Today: " << todaysDate.
weekday()
                  << ", " << todaysDate << std::endl;
        std::cout << "Settlement date: " << settlementDate.weekday()
                  << ", " << settlementDate << std::endl;
        
        
        Rate fra3x6Quote=0.037125;
         Rate fra6x9Quote=0.037125;
         Rate fra6x12Quote=0.037125;
         
        
        
        
        
        
        
        boost::shared_ptr<Quote> d1wRate(
new SimpleQuote(d1wQuote));
        boost::shared_ptr<Quote> d1mRate(
new SimpleQuote(d1mQuote));
        boost::shared_ptr<Quote> d3mRate(
new SimpleQuote(d3mQuote));
        boost::shared_ptr<Quote> d6mRate(
new SimpleQuote(d6mQuote));
        boost::shared_ptr<Quote> d9mRate(
new SimpleQuote(d9mQuote));
        boost::shared_ptr<Quote> d1yRate(
new SimpleQuote(d1yQuote));
        
        boost::shared_ptr<Quote> fra3x6Rate(
new SimpleQuote(fra3x6Quote));
        boost::shared_ptr<Quote> fra6x9Rate(
new SimpleQuote(fra6x9Quote));
        boost::shared_ptr<Quote> fra6x12Rate(
new SimpleQuote(fra6x12Quote));
        
        boost::shared_ptr<Quote> fut1Price(
new SimpleQuote(fut1Quote));
        boost::shared_ptr<Quote> fut2Price(
new SimpleQuote(fut2Quote));
        boost::shared_ptr<Quote> fut3Price(
new SimpleQuote(fut3Quote));
        boost::shared_ptr<Quote> fut4Price(
new SimpleQuote(fut4Quote));
        boost::shared_ptr<Quote> fut5Price(
new SimpleQuote(fut5Quote));
        boost::shared_ptr<Quote> fut6Price(
new SimpleQuote(fut6Quote));
        boost::shared_ptr<Quote> fut7Price(
new SimpleQuote(fut7Quote));
        boost::shared_ptr<Quote> fut8Price(
new SimpleQuote(fut8Quote));
        
        boost::shared_ptr<Quote> s2yRate(
new SimpleQuote(s2yQuote));
        boost::shared_ptr<Quote> s3yRate(
new SimpleQuote(s3yQuote));
        boost::shared_ptr<Quote> s5yRate(
new SimpleQuote(s5yQuote));
        boost::shared_ptr<Quote> s10yRate(
new SimpleQuote(s10yQuote));
        boost::shared_ptr<Quote> s15yRate(
new SimpleQuote(s15yQuote));
        
        
        
        
        
        
            1*Weeks, fixingDays,
            true, depositDayCounter));
            1*Months, fixingDays,
            true, depositDayCounter));
            3*Months, fixingDays,
            true, depositDayCounter));
            6*Months, fixingDays,
            true, depositDayCounter));
            9*Months, fixingDays,
            true, depositDayCounter));
            1*Years, fixingDays,
            true, depositDayCounter));
        
            true, depositDayCounter));
            true, depositDayCounter));
            true, depositDayCounter));
        
        
            imm,
            true, depositDayCounter));
            imm,
            true, depositDayCounter));
            imm,
            true, depositDayCounter));
            imm,
            true, depositDayCounter));
            imm,
            true, depositDayCounter));
            imm,
            true, depositDayCounter));
            imm,
            true, depositDayCounter));
            imm,
            true, depositDayCounter));
        
        boost::shared_ptr<IborIndex> swFloatingLegIndex(
new Euribor6M);
            calendar, swFixedLegFrequency,
            swFixedLegConvention, swFixedLegDayCounter,
            swFloatingLegIndex));
            calendar, swFixedLegFrequency,
            swFixedLegConvention, swFixedLegDayCounter,
            swFloatingLegIndex));
            calendar, swFixedLegFrequency,
            swFixedLegConvention, swFixedLegDayCounter,
            swFloatingLegIndex));
            calendar, swFixedLegFrequency,
            swFixedLegConvention, swFixedLegDayCounter,
            swFloatingLegIndex));
            calendar, swFixedLegFrequency,
            swFixedLegConvention, swFixedLegDayCounter,
            swFloatingLegIndex));
        
        
        
        double tolerance = 1.0e-15;
        
        std::vector<boost::shared_ptr<RateHelper> > depoSwapInstruments;
        depoSwapInstruments.push_back(d1w);
        depoSwapInstruments.push_back(d1m);
        depoSwapInstruments.push_back(d3m);
        depoSwapInstruments.push_back(d6m);
        depoSwapInstruments.push_back(d9m);
        depoSwapInstruments.push_back(d1y);
        depoSwapInstruments.push_back(s2y);
        depoSwapInstruments.push_back(s3y);
        depoSwapInstruments.push_back(s5y);
        depoSwapInstruments.push_back(s10y);
        depoSwapInstruments.push_back(s15y);
        boost::shared_ptr<YieldTermStructure> depoSwapTermStructure(
                                          settlementDate, depoSwapInstruments,
                                          termStructureDayCounter,
                                          tolerance));
        
        std::vector<boost::shared_ptr<RateHelper> > depoFutSwapInstruments;
        depoFutSwapInstruments.push_back(d1w);
        depoFutSwapInstruments.push_back(d1m);
        depoFutSwapInstruments.push_back(fut1);
        depoFutSwapInstruments.push_back(fut2);
        depoFutSwapInstruments.push_back(fut3);
        depoFutSwapInstruments.push_back(fut4);
        depoFutSwapInstruments.push_back(fut5);
        depoFutSwapInstruments.push_back(fut6);
        depoFutSwapInstruments.push_back(fut7);
        depoFutSwapInstruments.push_back(fut8);
        depoFutSwapInstruments.push_back(s3y);
        depoFutSwapInstruments.push_back(s5y);
        depoFutSwapInstruments.push_back(s10y);
        depoFutSwapInstruments.push_back(s15y);
        boost::shared_ptr<YieldTermStructure> depoFutSwapTermStructure(
                                       settlementDate, depoFutSwapInstruments,
                                       termStructureDayCounter,
                                       tolerance));
        
        std::vector<boost::shared_ptr<RateHelper> > depoFRASwapInstruments;
        depoFRASwapInstruments.push_back(d1w);
        depoFRASwapInstruments.push_back(d1m);
        depoFRASwapInstruments.push_back(d3m);
        depoFRASwapInstruments.push_back(fra3x6);
        depoFRASwapInstruments.push_back(fra6x9);
        depoFRASwapInstruments.push_back(fra6x12);
        depoFRASwapInstruments.push_back(s2y);
        depoFRASwapInstruments.push_back(s3y);
        depoFRASwapInstruments.push_back(s5y);
        depoFRASwapInstruments.push_back(s10y);
        depoFRASwapInstruments.push_back(s15y);
        boost::shared_ptr<YieldTermStructure> depoFRASwapTermStructure(
                                       settlementDate, depoFRASwapInstruments,
                                       termStructureDayCounter,
                                       tolerance));
        
        
        
        
        
        Real nominal = 1000000.0;
         
        
        boost::shared_ptr<IborIndex> euriborIndex(
        VanillaSwap::Type swapType = VanillaSwap::Payer;
        Date maturity = settlementDate + lenghtInYears*Years;
         Schedule fixedSchedule(settlementDate, maturity,
                                calendar, fixedLegConvention,
                               fixedLegConvention,
        Schedule floatSchedule(settlementDate, maturity,
                                calendar, floatingLegConvention,
                               floatingLegConvention,
            fixedSchedule, fixedRate, fixedLegDayCounter,
            floatSchedule, euriborIndex, spread,
            floatingLegDayCounter);
        Date fwdStart = calendar.
advance(settlementDate, 1, Years);
         Date fwdMaturity = fwdStart + lenghtInYears*Years;
         Schedule fwdFixedSchedule(fwdStart, fwdMaturity,
                                   calendar, fixedLegConvention,
                                  fixedLegConvention,
        Schedule fwdFloatSchedule(fwdStart, fwdMaturity,
                                   calendar, floatingLegConvention,
                                  floatingLegConvention,
            fwdFixedSchedule, fixedRate, fixedLegDayCounter,
            fwdFloatSchedule, euriborIndex, spread,
            floatingLegDayCounter);
        
        
        std::vector<std::string> headers(4);
        headers[0] = "term structure";
        headers[1] = "net present value";
        headers[2] = "fair spread";
        headers[3] = "fair fixed rate";
        std::string separator = " | ";
        Size width = headers[0].size() + separator.size()
                    + headers[1].size() + separator.size()
                   + headers[2].size() + separator.size()
                   + headers[3].size() + separator.size() - 1;
        std::string rule(width, '-'), dblrule(width, '=');
        std::string tab(8, ' ');
        
        std::cout << dblrule << std::endl;
        std::cout <<  "5-year market swap-rate = "
                  << std::setprecision(2) << 
io::rate(s5yRate->value())
                  << std::endl;
        std::cout << dblrule << std::endl;
        std::cout << tab << "5-years swap paying "
        std::cout << headers[0] << separator
                  << headers[1] << separator
                  << headers[2] << separator
                  << headers[3] << separator << std::endl;
        std::cout << rule << std::endl;
        boost::shared_ptr<PricingEngine> swapEngine(
                         new DiscountingSwapEngine(discountingTermStructure));
        spot5YearSwap.setPricingEngine(swapEngine);
        oneYearForward5YearSwap.setPricingEngine(swapEngine);
        
        forecastingTermStructure.
linkTo(depoSwapTermStructure);
        discountingTermStructure.linkTo(depoSwapTermStructure);
        NPV = spot5YearSwap.NPV();
        fairSpread = spot5YearSwap.fairSpread();
        fairRate = spot5YearSwap.fairRate();
        std::cout << std::setw(headers[0].size())
                  << "depo-swap" << separator;
        std::cout << std::setw(headers[1].size())
                  << std::fixed << std::setprecision(2) << NPV << separator;
        std::cout << std::setw(headers[2].size())
        std::cout << std::setw(headers[3].size())
        std::cout << std::endl;
        
        QL_REQUIRE(std::fabs(fairRate-s5yQuote)<1e-8,
                   "5-years swap mispriced by "
                   << 
io::rate(std::fabs(fairRate-s5yQuote)));
        forecastingTermStructure.linkTo(depoFutSwapTermStructure);
        discountingTermStructure.linkTo(depoFutSwapTermStructure);
        NPV = spot5YearSwap.NPV();
        fairSpread = spot5YearSwap.fairSpread();
        fairRate = spot5YearSwap.fairRate();
        std::cout << std::setw(headers[0].size())
                  << "depo-fut-swap" << separator;
        std::cout << std::setw(headers[1].size())
                  << std::fixed << std::setprecision(2) << NPV << separator;
        std::cout << std::setw(headers[2].size())
        std::cout << std::setw(headers[3].size())
        std::cout << std::endl;
        QL_REQUIRE(std::fabs(fairRate-s5yQuote)<1e-8,
                   "5-years swap mispriced!");
        forecastingTermStructure.linkTo(depoFRASwapTermStructure);
        discountingTermStructure.linkTo(depoFRASwapTermStructure);
        NPV = spot5YearSwap.NPV();
        fairSpread = spot5YearSwap.fairSpread();
        fairRate = spot5YearSwap.fairRate();
        std::cout << std::setw(headers[0].size())
                  << "depo-FRA-swap" << separator;
        std::cout << std::setw(headers[1].size())
                  << std::fixed << std::setprecision(2) << NPV << separator;
        std::cout << std::setw(headers[2].size())
        std::cout << std::setw(headers[3].size())
        std::cout << std::endl;
        QL_REQUIRE(std::fabs(fairRate-s5yQuote)<1e-8,
                   "5-years swap mispriced!");
        std::cout << rule << std::endl;
        
        std::cout << tab << "5-years, 1-year forward swap paying "
        std::cout << headers[0] << separator
                  << headers[1] << separator
                  << headers[2] << separator
                  << headers[3] << separator << std::endl;
        std::cout << rule << std::endl;
        forecastingTermStructure.linkTo(depoSwapTermStructure);
        discountingTermStructure.linkTo(depoSwapTermStructure);
        NPV = oneYearForward5YearSwap.NPV();
        fairSpread = oneYearForward5YearSwap.fairSpread();
        fairRate = oneYearForward5YearSwap.fairRate();
        std::cout << std::setw(headers[0].size())
                  << "depo-swap" << separator;
        std::cout << std::setw(headers[1].size())
                  << std::fixed << std::setprecision(2) << NPV << separator;
        std::cout << std::setw(headers[2].size())
        std::cout << std::setw(headers[3].size())
        std::cout << std::endl;
        forecastingTermStructure.linkTo(depoFutSwapTermStructure);
        discountingTermStructure.linkTo(depoFutSwapTermStructure);
        NPV = oneYearForward5YearSwap.NPV();
        fairSpread = oneYearForward5YearSwap.fairSpread();
        fairRate = oneYearForward5YearSwap.fairRate();
        std::cout << std::setw(headers[0].size())
                  << "depo-fut-swap" << separator;
        std::cout << std::setw(headers[1].size())
                  << std::fixed << std::setprecision(2) << NPV << separator;
        std::cout << std::setw(headers[2].size())
        std::cout << std::setw(headers[3].size())
        std::cout << std::endl;
        forecastingTermStructure.linkTo(depoFRASwapTermStructure);
        discountingTermStructure.linkTo(depoFRASwapTermStructure);
        NPV = oneYearForward5YearSwap.NPV();
        fairSpread = oneYearForward5YearSwap.fairSpread();
        fairRate = oneYearForward5YearSwap.fairRate();
        std::cout << std::setw(headers[0].size())
                  << "depo-FRA-swap" << separator;
        std::cout << std::setw(headers[1].size())
                  << std::fixed << std::setprecision(2) << NPV << separator;
        std::cout << std::setw(headers[2].size())
        std::cout << std::setw(headers[3].size())
        std::cout << std::endl;
        
        
        
        
        
        
        
        
        boost::shared_ptr<SimpleQuote> fiveYearsRate =
        std::cout << dblrule << std::endl;
        std::cout <<  "5-year market swap-rate = "
                  << 
io::rate(s5yRate->value()) << std::endl;
        std::cout << dblrule << std::endl;
        std::cout << tab << "5-years swap paying "
        std::cout << headers[0] << separator
                  << headers[1] << separator
                  << headers[2] << separator
                  << headers[3] << separator << std::endl;
        std::cout << rule << std::endl;
        
        forecastingTermStructure.linkTo(depoSwapTermStructure);
        discountingTermStructure.linkTo(depoSwapTermStructure);
        NPV = spot5YearSwap.NPV();
        fairSpread = spot5YearSwap.fairSpread();
        fairRate = spot5YearSwap.fairRate();
        std::cout << std::setw(headers[0].size())
                  << "depo-swap" << separator;
        std::cout << std::setw(headers[1].size())
                  << std::fixed << std::setprecision(2) << NPV << separator;
        std::cout << std::setw(headers[2].size())
        std::cout << std::setw(headers[3].size())
        std::cout << std::endl;
        QL_REQUIRE(std::fabs(fairRate-s5yRate->value())<1e-8,
                   "5-years swap mispriced!");
        forecastingTermStructure.linkTo(depoFutSwapTermStructure);
        discountingTermStructure.linkTo(depoFutSwapTermStructure);
        NPV = spot5YearSwap.NPV();
        fairSpread = spot5YearSwap.fairSpread();
        fairRate = spot5YearSwap.fairRate();
        std::cout << std::setw(headers[0].size())
                  << "depo-fut-swap" << separator;
        std::cout << std::setw(headers[1].size())
                  << std::fixed << std::setprecision(2) << NPV << separator;
        std::cout << std::setw(headers[2].size())
        std::cout << std::setw(headers[3].size())
        std::cout << std::endl;
        QL_REQUIRE(std::fabs(fairRate-s5yRate->value())<1e-8,
                   "5-years swap mispriced!");
        forecastingTermStructure.linkTo(depoFRASwapTermStructure);
        discountingTermStructure.linkTo(depoFRASwapTermStructure);
        NPV = spot5YearSwap.NPV();
        fairSpread = spot5YearSwap.fairSpread();
        fairRate = spot5YearSwap.fairRate();
        std::cout << std::setw(headers[0].size())
                  << "depo-FRA-swap" << separator;
        std::cout << std::setw(headers[1].size())
                  << std::fixed << std::setprecision(2) << NPV << separator;
        std::cout << std::setw(headers[2].size())
        std::cout << std::setw(headers[3].size())
        std::cout << std::endl;
        QL_REQUIRE(std::fabs(fairRate-s5yRate->value())<1e-8,
                   "5-years swap mispriced!");
        std::cout << rule << std::endl;
        
        std::cout << tab << "5-years, 1-year forward swap paying "
        std::cout << headers[0] << separator
                  << headers[1] << separator
                  << headers[2] << separator
                  << headers[3] << separator << std::endl;
        std::cout << rule << std::endl;
        forecastingTermStructure.linkTo(depoSwapTermStructure);
        discountingTermStructure.linkTo(depoSwapTermStructure);
        NPV = oneYearForward5YearSwap.NPV();
        fairSpread = oneYearForward5YearSwap.fairSpread();
        fairRate = oneYearForward5YearSwap.fairRate();
        std::cout << std::setw(headers[0].size())
                  << "depo-swap" << separator;
        std::cout << std::setw(headers[1].size())
                  << std::fixed << std::setprecision(2) << NPV << separator;
        std::cout << std::setw(headers[2].size())
        std::cout << std::setw(headers[3].size())
        std::cout << std::endl;
        forecastingTermStructure.linkTo(depoFutSwapTermStructure);
        discountingTermStructure.linkTo(depoFutSwapTermStructure);
        NPV = oneYearForward5YearSwap.NPV();
        fairSpread = oneYearForward5YearSwap.fairSpread();
        fairRate = oneYearForward5YearSwap.fairRate();
        std::cout << std::setw(headers[0].size())
                  << "depo-fut-swap" << separator;
        std::cout << std::setw(headers[1].size())
                  << std::fixed << std::setprecision(2) << NPV << separator;
        std::cout << std::setw(headers[2].size())
        std::cout << std::setw(headers[3].size())
        std::cout << std::endl;
        forecastingTermStructure.linkTo(depoFRASwapTermStructure);
        discountingTermStructure.linkTo(depoFRASwapTermStructure);
        NPV = oneYearForward5YearSwap.NPV();
        fairSpread = oneYearForward5YearSwap.fairSpread();
        fairRate = oneYearForward5YearSwap.fairRate();
        std::cout << std::setw(headers[0].size())
                  << "depo-FRA-swap" << separator;
        std::cout << std::setw(headers[1].size())
                  << std::fixed << std::setprecision(2) << NPV << separator;
        std::cout << std::setw(headers[2].size())
        std::cout << std::setw(headers[3].size())
        std::cout << std::endl;
        double seconds = timer.elapsed();
        seconds -= hours * 3600;
        seconds -= minutes * 60;
        std::cout << " \nRun completed in ";
        if (hours > 0)
            std::cout << hours << " h ";
        if (hours > 0 || minutes > 0)
            std::cout << minutes << " m ";
        std::cout << std::fixed << std::setprecision(0)
                  << seconds << " s\n" << std::endl;
        return 0;
    } catch (std::exception& e) {
        std::cerr << e.what() << std::endl;
        return 1;
    } catch (...) {
        std::cerr << "unknown error" << std::endl;
        return 1;
    }
}