Limit number of std::string allocations

"My question is, how can I minimize these allocations"

It occurs to me that you have a reason for those names. Can you compute them at the time of need, rather than always generating the name in the constructor? That would be the best improvement - don't do it at all until needed.

If you happen to already have a virtual base, and the class type determines the string, that makes it really easy. Otherwise, an enumerated type could replace the string, and you have a lookup table.

Object* object1= new Object(i, j));
std::string Object::getName(){ compute here }

If this doesn't help, then you actually do need the string for each and every object, and you can only get a small speedup by optimizing that function. I noticed that you construct the string at one size then grow it afterwards. Also you could work with a char buffer then assign it to the member string (in the constructor).

Yes, your code is doing a lot of allocations. Analyzing the allocations:

std::string new_name(name); // 1
new_name.reserve(new_name.length()+5); // 2

new_name += ":";
new_name += boost::lexical_cast<std::string>(num1); // possibly 4 (boost + operator+=)
new_name += ":"; // possibly 5
new_name += boost::lexical_cast<std::string>(num2); // possibly 7

'possibly' because it depends on the characters needed by the numbers (the higher, the more).

If you're really concerned about memory allocations, asprintf(not standard though) or your version (based on the return value of s(n)printf) is likely to be the best choice:

std::string makeName(const char* name, uint16_t num1, uint16_t num2)
{
     char *ptr = nullptr; 
     int size  = asprintf( &ptr, "%s:%u:%u", name, num1, num2);
  return std::string(ptr, size); // to avoid copying the chars
}  

Note: As @Cheersandhth.-Alf pointed out, in case std::string failed to allocate memory, ptr would be ptr is leaked. The best way to solve this would involve using std::unique_ptr but I'll leave you to work it out to your needs.

if you don't want to use asprintf, you can get a similar behavior with std::snprintf

std::string makeName(const char* name, uint16_t num1, uint16_t num2)
{
    int length = std::snprintf(nullptr, 0, "%s:%u:%u", name, num1, num2);

    if (length > 0 )
    {
        std::string new_name(length + 1, '\0');
        std::snprintf(&new_name[0], new_name.length(), "%s:%u:%u", name, num1, num2);

       return new_name;
    } 
    // else handle failure
} 

The difference with your version (I didn't use boost::lexical_cast but std::to_string) is very big: ran 500 times the first version uses 72,890 bytes while the second only 23,890! (measured with valgrind memcheck)