# V302. Member operator[] of 'foo' class has a 32-bit type argument. Use memsize-type here.

The analyzer detected a potential error of working with classes that contain operator[]. Classes with an overloaded operator[] are usually a kind of an array where the index of the item being called is operator[] argument. If operator[] has a 32-bit type argument it might indicate an error.

Let us consider an example leading to the warning V302:

    class MyArray {
      std::vector<float> m_arr;
      ...
      float &operator[](int i)  //V302
      {
        DoSomething();
        return m_arr[i];
      }
    } A;
    ...
    int x = 2000;
    int y = 2000;
    int z = 2000;
    A[x * y * z] = 33;

If the class is designed to work with many arguments, implementing operator[] like this is incorrect because it does not allow addressing the items whose numbers are more than UINT_MAX. To diagnose the error in the example above you should point to the potentially incorrect operator[]. The expression "x * y * z" does not look suspicious because there is no implicit type conversion. When we correct operator[] in the following way:

    float &operator[](ptrdiff_t i);

PVS-Studio analyzer warns about a potential error in the line "A[x * y * z] = 33;" and now we can make the code absolutely correct. Here is an example of the corrected code:

    class MyArray {
      std::vector<float> m_arr;
      ...
      float &operator[](ptrdiff_t i)  //V302
      {
        DoSomething();
        return m_arr[i];
      }
    } A;
    ...
    ptrdiff_t x = 2000;
    ptrdiff_t y = 2000;
    ptrdiff_t z = 2000;
    A[x * y * z] = 33;

The related diagnostic warnings are V108 and V120.