Simple class for 2D <-> 1D array index conversion

Use modulus

Instead if this i-x*cols_ you can use the modulus operator i % cols_.

Use a unsigned type.

If you use unsigned there is no need to check for x >= 0 && y >= 0. Also you can con throw the exception directly in check. And you just need check_xy.

    void IndexConv::check(unsigned x, unsigned y) const
    {
        if(x >= rows_ || y >= cols_) 
            throw std::out_of_range("IndexConv: parameter out of bounds.");
    }

    pair<int, int> IndexConv::to_xy(unsigned i) const
    {
        int x = i / cols_;
        int y = i % cols_;
        check(x, y);
        return make_pair(x, y);
    }

    int IndexConv::to_i(unsigned x, unsigned y) const
    {
        check(x, y);
        return x * cols_ + y;
    }

EDIT: Changed the answer to keep check_xy. Keeping check_i can map (0,2) to 2 when it should throw an exception (Following your example).

In addition to the excellent suggestions by @MAG, I suggest the following:

A better class name

I suggest using a full name rather than a shorter name - IndexConverter.

No need to use const in member variables

I don't see any benefit of using const member variables. You can simply use (I am incorporating the suggestion to use an unsigned type):

unsigned int rows_;
unsigned int cols_;

Define a size type

To further enhance consistency in the class, define a size type in your class and use it.

class IndexConverter
{
   public:

      using size_type = unsigned int;

      IndexConverter(size_type rows, size_type cols);
      bool check_i(size_type i) const;
      bool check_xy(size_type x, size_type y) const;
      pair<size_type, size_type> to_xy(size_type i) const;
      size_type to_i(size_type x, size_type y) const;
   private:
      size_type rows_;
      size_type cols_;
};

This allows you to change the type used for size with minimal disruption.

Use std::pair instead of pair

Your use of

pair<int, int> to_xy(int i) const;

works presumably because you have added

using namespace std;

in the .h file before the definition of the class. See Why is “using namespace std;” considered bad practice?.

Remove the using line and use std::pair.

Better names for to_i and to_xy

I would suggest using to_1d_index and to_2d_index instead.

In the same vein, I would suggest using check_1d_index and check_2d_index. If you follow the suggestion by @MAG, then you need just check_2d_index.

Add an overload of to_1d_index

      size_type to_1d_index(std::pair<size_type, size_type> xy) const;

This is a convenience so that you can use something like:

IndexConverter c(10, 20);
unsigned int i = 2;
auto 2d_index = c.to_2d_index(i);
auto j = c.to_1d_index(2d_index);

and expect to see j == i.

Adding whitespaces

Adding a blank line between function declarations makes it easier to read. That could be my personal taste! YMMV.

Final Suggested Version

class IndexConverter
{
   public:

      using size_type = unsigned it;

      IndexConverter(size_type rows, size_type cols);

      void check_2d_index(size_type x, size_type y) const;

      std::pair<size_type, size_type> to_2d_index(size_type i) const;

      size_type to_1d_index(size_type x, size_type y) const;

      size_type to_1d_index(std::pair<size_type, size_type> xy) const;

   private:
      size_type rows_;
      size_type cols_;
};