Предупреждение C ++: не все пути управления возвращают значение

Question

Что ж, у меня есть несколько предупреждений, которые приводят к тому, что моя программа обрабатывает sh, когда я ввожу размер 3.
Не все пути управления возвращают значение.

Я пытаюсь решить матрицу N, ввод, вывод и некоторые операции. Я храню первый столбец

 _vec[0:size-1],last column _vec[size : (size*2)-1]

и диагональ

 _vec[size*2 : size*3-2]

матрицы в массиве 1-dimensional. Размер массива равен matrix * 3 -2. Проблема возникает при перегрузке операторов ():

int _size = (_vec.size() +2) /3;   
// when I switch from vector size to normal matrix size. f.e vector size: 7,
// my matrix size is 3. 

int Matrix::operator()(int i, int j) const
    {
        int _size = (_vec.size() +2) /3;
        if ((i >= _size || i < 0) || (j >= _size || j < 0)) throw OVERINDEXED;
        if (i != j && j != 0 && j != _size - 1) return 0;
        else {
            if (j == 0)
            {
                return _vec[i];
            }
            else if (j == _size - 1)
            {
                return _vec[_size + i];
            }
            else if (i == j && j != 0 && j != _size - 1)
            {
                return _vec[(_size * 2) + i];
            }
        }
    }

    int& Matrix::operator()(int i, int j)
    {
        int _size = (_vec.size() +2) /3;
        if ((i >= _size || i < 0) || (j >= _size || j < 0)) throw OVERINDEXED;
        if (i != j && j != 0 && j != _size - 1) throw NULLPART;
        else {
            if (j == 0)
            {
                return _vec[i];
            }
            else if (j == _size - 1)
            {
                return _vec[_size + i];
            }
            else if (i == j && j != 0 && j != _size - 1)
            {
                return _vec[(_size * 2) + i];
            }
        }
    }

Answer 1

Требуется некоторый анализ, чтобы доказать, что все случаи возвращаются.

И, похоже, ваш компилятор не выполняет полный анализ

int Matrix::operator()(int i, int j) const
{
    int _size = (_vec.size() + 2) /3;
    if ((i >= _size || i < 0) || (j >= _size || j < 0)) throw OVERINDEXED;
    if (i != j && j != 0 && j != _size - 1) return 0;
    else {
        if (j == 0)
        {
            return _vec[i];
        }
        else if (j == _size - 1)
        {
            return _vec[_size + i];
        }
        else if (i == j && j != 0 && j != _size - 1)
        {
            return _vec[(_size * 2) + i];
        }
        else
        {
             // No return here.
             // But is this case reachable?
             // yes, for (i, j) respecting:
             //    (0 <= i && i < _size) && (0 <= j && j < _size)
             //    && ((i == j) || (j == 0) || (j == _size - 1)) // #2
             //    && (j != 0) && (j != _size - 1)               // #1
             //    && (i != j || j == 0 || j == _size - 1)       // #3
             // which after simplification results indeed in false.
             // #1 simplifies #2 to (i == j) and #3 to (i != j)
        }
    }
}

С другой стороны, это означает, что вы делать бесполезные «тесты», которые вы можете удалить (и так, пожалуйста, компилятор):

int Matrix::operator()(int i, int j) const
{
    int _size = (_vec.size() + 2) /3;
    if ((i >= _size || i < 0) || (j >= _size || j < 0)) throw OVERINDEXED;
    if (i != j && j != 0 && j != _size - 1) return 0;
    else {
        if (j == 0)
        {
            return _vec[i];
        }
        else if (j == _size - 1)
        {
            return _vec[_size + i];
        }
        else // We have necessary (i == j && j != 0 && j != _size - 1)
        {
            return _vec[(_size * 2) + i];
        }
    }
}

Answer 2

Измените код, как показано ниже, для второй функции.

int Matrix::operator()(int i, int j) const
{
    int _size = (_vec.size() + 2) / 3;
    if ((i >= _size || i < 0) || (j >= _size || j < 0)) throw OVERINDEXED;
    if (i != j && j != 0 && j != _size - 1) return 0;
    else {
        if (j == 0)
        {
            return _vec[i];
        }
        else if (j == _size - 1)
        {
            return _vec[_size + i];
        }
        else if (i == j && j != 0 && j != _size - 1)
        {
            return _vec[(_size * 2) + i];
        }
    }
    return 0; // added this line
}