Overall it looks fine for a newcomer, you've made proper use of const for variables and methods, which is something beginners tend to overlook.

A few points you can still work on:

1. For such a tiny class like Tone, I would not bother separating declaration from implementation and would have declared it inline in the header file only. That would be less boilerplate and easier to maintain. A word of caution though: Inline code can be better optimized by the compiler and is recommend for small methods (like get/set accessors), but don't overuse it. Too much inlining will increase compile-times and generate bloated executables. I don't recommend it as an optimization either, the gain is in reducing redundant/boilerplate code implicit in the prototype/implementation setup.

2. Prefixing in-class member access with this-> is very rare in C++. You should only be doing that when, for instance, you need to disambiguate some shadowed member access (but even that is discouraged because shadowing members is a bit of a design flaw; better to uniquely identify your variables).

3. This is a personal preference, I find it better to declare public members of a class first, followed by protected and then private. My rationale is that the public section should have more emphasis, since it is what readers and users of my code will be interested on most of the time. Private/protected details are of interest for the implementer/maintainer, so they don't need to be visible right at the top of the file.

4. When using <cmath>, the correct way of referencing its functions, like sin/pow, is thru the std:: namespace. They happen to visible at the global level because on most compilers math.h (the C header) and cmath are implemented as wrappers to the same file. There is no requirement from the C++ Standard that this be implemented is such way, so a C++ compiler is not required to provide sin() outside the std namespace when including cmath.

5. Avoid using C-style casts. To cast numerical values, C++ provides static_cast. To cast pointers, reinterpret_cast is usually the operator to use. A quick overview on C++ cast operators.

6. Yes, size_t and int16_t are part of the Standard and are declared in <cstddef> and <cstdint> respectively. For ultimate correctness, they should be accessed from the std namespace, (e.g.: std::size_t, std:int16_t) for the same reasons cited on §4.

7. Your main() function is too long and doing too much. You should probably have another class, Sample perhaps, that holds the array of Tones. That class should provide methods for processing and have write_sample() as a member.

8. There is a much simpler way of initializing the tones vector. You can fill it with defaults on declaration using a parameterized constructor and eliminate the loop:

   std::vector<Tone> tones(count, Tone(SAMPLE_RATE));
   

9. If you use an std::array you gain the size() method that knows the array length, which would remove the need for the sizeof() calculation, which is not the clearest thing you can do. Another way I tend to use for inferring the length of statically allocated arrays, without compromising readability, is by declaring a helper template function:

   // Length in elements of type 'T' of statically allocated C++ arrays.
   template<class T, std::size_t N>
   constexpr std::size_t arrayLength(const T (&)[N])
   {
       return N;
   }
   
   ...
   
   const double octaves[] = { -2, 0, 4./12, 7./12, 1, 16./12, 19./12 };
   const auto count = arrayLength(octaves);
   

   constexpr will force the function to be evaluated at compile time, thus making it suitable for use in places a compile-time constant would be required.

What @glampert said:

Dead Code

double Tone::getSample() const
{
    return this->lastSample;
}

This is never used. Also looks like a dreaded getter so probably don't want it anyway.

Easier iteration

const double octaves[] = { -2, 0, 4./12, 7./12, 1, 16./12, 19./12 };
const size_t count = sizeof(octaves) / sizeof(*octaves);

    for (size_t i = 0; i < count; i++)
    {
        double octave = interp * octaves[i];
        // STUFF
    }

I would say it is easier to use the C++ std::Array (or vector)

 std::vector<double> const octaves = { -2, 0, 4./12, 7./12, 1, 16./12, 19./12 };

    for(double octVal : octaves)
    {
        double octave = interp * octVal;
        // STUFF

    }

Prefer Emplace to Push

// Create a tone generator for each
for (size_t i = 0; i < count; i++)
{
    tones.push_back(Tone(SAMPLE_RATE));
}

This creates a temporary object then copy constructs it into the tones vector (you may get a move if you have a move constructor). But you can get the vecotr to build the object in place rather than creating a temporary then copying by using emplace.

// Create a tone generator for each
for (size_t i = 0; i < count; i++)
{
    tones.emplace_back(SAMPLE_RATE); // You pass all the arguments the constructor takes
                                     // Even if this is more than one. The emplace_back
                                     // forwards all the parameters to the constructor
                                     // and does an inplace create in the vector.
}

No need to check this every iteration of the loop;

    if (outfile.good())
    {
        write_sample(outfile, totalSample);
    }
    else
    {
        return 1;
    }
}

return 0;

If the stream has gone bad then writing to it will not do anything. Also a stream going bad is a very expcetional thing so I would just test for it at the end of the function not every time through the loop.

I would simplify the above code too:

    write_sample(outfile, totalSample);        
}

return outfile.good() ? 0 : 1;

C Style cast

Don't use them. They are hard to find and the cause of a lot of errors. Use the C++ cast (which are easy to find) and are slightly more nuanced.

int16_t output = (int16_t) (0x7FFF * sample);

Don't believe that line actually needs a cast. If it warns you about loosing precision then by then you should use a cast (to let the compiler know you know what you are doing and are willing to loose precision) but it should be a static_cast<int16_t>()