How to get accurate result of two double value division if one is divisible by another?

If one double value is already known divisible by another(that is, a/b gives an integer in mathmatics), how can I get the accurate integer result in C++? example code

int main(int argc, char* argv[]) {
  double price = 1235.1;
  double step = 0.1;
  // prints 12350, 12351 expected
  std::cout << int(price/step) << std::endl;

  price = 1235.2;
  step = 0.1;
  // prints 12352, ok
  std::cout << int(price/step) << std::endl;
};

To answer your exact question:

> If one double value is already known divisible by another(that is, a/b gives an integer in mathmatics), how can I get the accurate integer result in C++?

You just divide them by each other exactly as you would naively expect.

#include <iostream>
#include <iomanip> //std::setprecision

int main()
{
    std::cout << std::setprecision(20);

    //2^7, aka 128, exactly representable in double precision
    constexpr double price = 2.0*2.0*2.0*2.0*2.0*2.0*2.0; 
    std::cout << price << " = 2.0^7 exact\n";

    //(1/2)^4, aka 1/16, aka 0.0625, exactly representable in double precision
    constexpr double step = 0.5*0.5*0.5*0.5;
    std::cout << step << " = 0.5^4 exact\n";

    //(2^7)/((1/2)^4), exactly representable in double precision
    constexpr double d_result = price/step;
    std::cout << d_result << " = (2^7)/((1/2)^4) exact\n";

    // as an integer
    constexpr int i_result = d_result;
    std::cout << i_result << " = 2048 exact\n";

    //there is no difference between d_result and i_result
    constexpr double difference = d_result - i_result;
    static_assert(difference == 0.0);
}

This compiles, so the static assert establishes there is no difference between the integer representation and the double representation.

It prints:

128 = 2.0^7 exact
0.0625 = 0.5^4 exact
2048 = (2^7)/((1/2)^4) exact
2048 = 2048 exact

The reason this doesn't work for you:

Your doubles are known to not be evenly divisible by each other, because the value of step is not 0.1, it is 0.100000001490116119, which is the 64bit floating point number closest to real number 1/10.

If you want exactness like this, use a data type with exact representation, e.g. instead of storing dollars as a double, store cents as an integer. (Or use a library that provides arbitrary precision rational numbers. GMP is a popular choice when LGPL is an acceptable license)

You don't. Floating point numbers are not exact. If you want exact arithmetics do not use floating point numbers. As mentioned in a comment, rather than float dollars you can work with int cents.

However, conversion to int truncates the fractional part, hence, provided (int)price % (int) step == 0 and both are positive you can get the desired output via:

std::cout << int((price+step*0.5)/step) << std::endl;