Welcome to Larington Hotel, nestled in the heart Montreal, Quebec's wine country. Larington exudes luxury, elegance, and a charm that has no rival.
One Bedroom King Suite
$159.00
Two Bedroom Queen Suite
$199.00
Two Bedroom Luxury Suite
$299.00
Three Bedroom Penthouse Suite
$399.00
Our guests love the Larington Hotel experience.
Love the LH experience!!
"The staff treated me and my colleagues like royality. The accommodations for our New Professors conference were beyond amazing."
Home away from home...with Perks!
"My suite was like a home away from home, only with great perks. The service was next level."


Jammal Lord Career Information
Quarterback Jammal Lord was an ironman for Nebraska in his final two seasons, starting 27 consecutive games, while guiding one of the nation's most prolific rushing attacks. He made his way near the top of the Nebraska record book by the conclusion of his career. The Bayonne, N.J., native finished his senior season with 2,253 yards of total offense, pushing his career total to 5,421 yards, placing him in third on Nebraska's career list, trailing only Eric Crouch and Tommie Frazier. Lord moved into the top 10 on Nebraska's career rushing list with 79 yards in the Alamo Bowl against Michigan State. He finished his Husker career with 2,573 rushing yards to rank 10th in school history and second among NU quarterbacks. he also finished seventh on NU's career passing charts with 2,848 yards. Lord fell just shy of a second straight 1,000-1,000 season in 2003, passing for 1,305 yards to go with a team-high 948 rushing yards. Under Lord's direction, the Nebraska offense averaged 235.6 rushing yards per game in 2003 to rank seventh nationally. Lord averaged 72.9 yards rushing per game, sixth nationally among quarterbacks. He rushed for 100 yards three times as a senior, including a season-high 111 yards at Missouri, and had eight career 100-yard rushing games, the second-most by a Husker quarterback. Lord produced seven 100-yard passing games in 2003, and capped his career with a personal-best 160 yards in the Alamo Bowl win over Michigan State. He added a career-long 66-yard run in the Alamo Bowl. A talented all-around athlete, Lord was given an opportunity to continue his career as a safety after being chosen in the sixth round of the 2004 NFL Draft (175th overall selection) by the Houston Texans.*source www.Huskers.com


When created, the first shared_ptr object that controls a particular resource allocates a control block from the heap. This allocation might fail, and the allocation code would throw an exception object of type bad_alloc. When that happens, the shared_ptr code that is creating the block will destroy the resource and rethrow the exception. This prevents memory leaks in typical code that looks like this:
shared_ptr<resource> sp(new resource(3));
If shared_ptr didn't do this, you'd have to store the pointer returned by new, enter a TRy block, initialize the shared_ptr object, and handle the possible exception by destroying the object. It's much easier to have that code in one place, inside the implementation of shared_ptr.
Example 2.42. Exceptions (smartptr/exceptions.cpp)
#include <memory>
#include <stdlib.h>
#include <iostream>
#include <new>
#include "sputil.h"
using std::tr1::shared_ptr;
using std::bad_alloc ; using std::cout;
static bool no_memory = false;
void *operator new(size_t sz)
{ // allocate memory, with one-shot failure
void *res;
bool no_mem = no_memory;
no_memory = false;
if (no_mem || (res = malloc (sz)) == 0)
throw bad_alloc ();
return res;
}
void operator delete (void *ptr)
{ // free allocated memory
free(ptr);
}
int main()
{ // demonstrate resource destruction on exception
try { // construct with no memory
cout << "construct with no memory :\n";
instrumented *ip = new instrumented;
no_memory = true;
shared_ptr<instrumented> sp0(ip);
}
catch(...)
{ // handle the exception
cout << " caught the exception \n";
}
try { // reset with no memory
cout << "reset with no memory:\n";
shared_ptr<instrumented> sp1;
instrumented *ip = new instrumented;
no_memory = true;
sp1.reset(ip);
}
catch(...)
{ // handle the exception
cout << " caught the exception\n";
}
return 0;
}