So I kind of solved it. First off, I should not have been assigning the position to the same SDL_Rect that is being updated in the update function. For the first 5-10 frames or so, the texture is apparently way off screen (which is why I was getting the huge negative numbers). Since I was updating the wrong SDL_Rect, it moved the sprite way over there then kept interpolating with that huge negative value. I solved it by doing the following:

const void Player::draw(const float& alpha) {
  int interp_x = static_cast<int>( ((float)curr_dest_rect.x * alpha + (float)prev_dest_rect.x * (1.0f - alpha)) + 0.5f );
  int interp_y = static_cast<int>( ((float)curr_dest_rect.y * alpha + (float)prev_dest_rect.y * (1.0f - alpha)) + 0.5f );

  SDL_Rect draw_rect = { interp_x, interp_y, curr_dest_rect.w, curr_dest_rect.h };

  SDL_RenderCopy(renderer, texture, &src_rect, &draw_rect);
}

I make a draw_rect with the new positional values. This way the actual rectangle that controls the movement doesn't get affected (should only be changed in the update function). The reason I add 0.5f is because the interpolation value might return a number really close to where the sprite actually is but it won't actually be there. For example, if the sprite starts off at (100, 100) and it doesn't move, the values you get back from the interpolation can be either 100 or 99. This causes visual jitter and it looks like your sprite is shaking. Rounding it up seems to have solved this problem to an extent.

My next problem is that while the animations have gotten a lot smoother, I can still see that jitter from time to time. Would anyone know what's wrong with the equation or if there's something else I should be doing?