String subscript out of range c ошибка

Подобные ошибки означают, что во время работы программы была предпринята попытка обращения к памяти, не подготовленной должным образом для этого. Программа с такими ошибками содержит неопределённое поведение. Самыми говорящими из рассмотренных в вопросе ошибок являются те, где сказано «subscript out of range». Дословно это переводится как «Индексация вне диапазона». Понятность их обеспечивается в первую очередь тем, что программа собрана в отладочном (Debug) режиме и соответствующий код индексации operator[] того или иного контейнера (std::array, std::string, std::vector) непосредственно содержит проверку значения индекса, передаваемого в оператор индексации. Например, так выглядит код в msvc 2019 для std::array:

    _NODISCARD _CONSTEXPR17 reference operator[](_In_range_(0, _Size - 1) size_type _Pos) noexcept /* strengthened */ {
#if _CONTAINER_DEBUG_LEVEL > 0
        _STL_VERIFY(_Pos < _Size, "array subscript out of range");
#endif // _CONTAINER_DEBUG_LEVEL > 0

        return _Elems[_Pos];
    }

Другие сообщения не так очевидны, потому что возникают при работе приложений, собранных без отладочной информации и/или оптимизированных так, что подробное отладочное сообщение не содержится/не связано с выполняемый кодом, но причины их возникновения часто те же самые.

Решение проблемы прямо вытекает из текста отладочных сообщений — индекс, по которому идёт обращение к элементу контейнера, должен быть в допустимом диапазоне. Т.е. если контейнер имеет размер N, допустимыми индексами будут являться 0...N-1. Исключением из этого правила является std::string, где допускается так же использовать индекс N, но с оговоркой, что писать туда можно только нулевой символ , и он же вернётся при чтении.

Довольно часто проблема выхода за допустимые границы диапазона случается в циклах, когда условие завершение содержит нестрогое сравнение индекса с размером контейнера: т.е. i <= size вместо i < size. В подобных случаях итерации по элементам, следует по возможности пользоваться диапазонной версией цикла for, которая не допускает выхода за пределы контейнера, если размер контейнера остаётся постоянным в процессе итерирования.

std::vector<int> v = {1, 2, 3};
for(int i = 0; i <= v.size(); ++i) // ошибка. <= вместо <
   v[i] = 42;                      // проблема на последней итерации

for(auto& e : v)                   // диапазонный for 
   e = 42;                         // e всегда принадлежит вектору

Иногда цикл кажется правильным, но вместо v.size() по незнанию указывают v.max_size(), который говорит вообще о потенциально возможном размере контейнера для данной архитектуры, а не о текущем размере. Понятно, что в этом случае можно выйти далеко за пределы разрешённых величин.

При этом даже в циклах, где правильно заданы границы индексов можно использовать не тот элемент, т.к. конкретный индекс вычисляется как функция от индекса из цикла, например:

for(int i = 0; i < v.size(); ++i) {
   v[f(i)] = ...   // f(i) может возвращать другой диапазон
   v[i - 1] = ...  // использование "предыдущего" индекса. Ошибка для i == 0.
}

Другой возможный случай — когда возникает путаница между ассоциативными контейнерами (где operator[] приводит к созданию/добавлению элемента в контейнер, если его ещё не было) и последовательными контейнерами. Например:

std::map<int, int> m;
m[0] = 42; // ok, добавляется элемент с ключом 0 и ему присваивается значение 42

std::vector<int> v;
v[0] = 42; // ошибка, вектор пустой, элемента с индексом 0 не существует

Добавить элемент в вектор можно либо при инициализации std::vector<int> v = {42};, либо позднее, например, через v.push_back(42).

Иногда ошибка может возникать, когда вместо std::vector::resize был вызван std::vector::reserve. Т.е. память выделена и доступ идёт только к элементам внутри выделенной памяти, но логически размер вектора не был изменён (элементы вектора фактически не проинициализированы). При Release сборке в этом случае может вовсе не возникнуть ошибки доступа (access violation), но такая программа не будет считаться валидной.

Чтобы обеспечить дополнительную проверку диапазона используемых индексов как в отладочном, так и в релизном режимах сборки вместо operator[] можно воспользоваться функцией at(), которая выбросит исключение std::out_of_range при использовании индекса вне разрешённого диапазона. В некоторых случаях сложного вычисления индекса это может быть оправдано, но внесёт дополнительный оверхед.

КОД:

#include <iostream>
#include <string>

using namespace std;

string codeNormalization(string code) {
	string result;
	for (int i = 0; i < code.size(); i++) {
		if (code[i] == 'n') {
			result += "\n";
		}
		else if (code[i] == '"') {
			result += ''';
		}
		else if (code[i] == 't') {
			result += "\t";
		}
		else {
			result += code[i];
		}
	}
	return result = R"("exec(''')" + result + "''')" + R"(")";
}

string myOBF(string codeLine) {
	string result;
	for (int i = 0; i < codeLine.capacity(); i++) {
		int _ord = (int)codeLine[i];
		if (codeLine[i] == codeLine[-1]) {
			result += "chr(" + to_string(_ord) + "))";
		}else if (codeLine[i] == codeLine[0]){
			result += "exec(chr(" + to_string(_ord) + ")+";
		}else {
			result += "chr(" + to_string(_ord) + ")+";
		}
	}
	return result;
}

int main() {
	string code = "print('txt')";
	cout <<myOBF(codeNormalization(code)) << endl;
	system("pause");
}

Ошибка появляется в MessageBox после появления консоли.
Сама ошибка:
string subscript out of range
При дебаге кидает в xstring
Ошибка появилась сразу после написания функции myOBF. <ОШИБКА ГДЕ ТО В НЕЙ>
Ошибка пропадает если из цикла for убрать все if и else if

моя часть кода делает проверку на путь ,который указывают для файла. В этом пути должны быть исключены все зарезервированные имена Windows ( из серии con,clock$ и т.п. ) , в целом я был уверен, что написал правильную функцию, но после запуска стало выдавать ошибку «string subscript out of range» . Подскажите , пожалуйста, в чём моя ошибка.

bool CheckFile(string path) {
        int retry = 0, numbers, point = 0, miniNameSize = 0, numberPoints;
        int sizePath = size(path);
                    for (numberPoints = sizePath; numberPoints >= 0; numberPoints--) {
                    if (path[numberPoints] == '.') {
                    point = numberPoints;
                    break;
                    }
                    for (int k = 0; k < sizePath; k++) {
                    if (path[k] == '.' && k != point ) {
                    path.erase(k, 1);
                    k--;
                    }
                    sizePath = size(path);
                    }
                    for (int k = 0; k < sizePath; k++) {
                    if (path[k] == ' ') {
                    path.erase(k, 1);
                    k--;
                    }
                    }
                    sizePath = size(path);
            for (numbers = 0; numbers < sizePath; ) {
            if ((path[numbers] == '\' || path[numbers] == '/') || numbers == 0) {
                for (int n = 1; (path[numbers + n] != '\' || path[numbers + n] != '/' || path[numbers + n] != '.'); n++) miniNameSize = n;
                // Работаем с именем 
                if (miniNameSize == 0) numbers++;
                else {
                    if (numbers == 0) numbers--;
                    for (int j = numbers + 1 ; j <= miniNameSize; ) {                                           // Аккуратно с j !!!!
                        if (miniNameSize - j < 3) break;
                        else {
                            if (j + 3 == miniNameSize + 1) {
                                if ((path[j] == 'n' || path[j] == 'N') && (path[j + 1] == 'u' || path[j + 1] == 'U') && (path[j + 2] == 'l' || path[j + 2] == 'L')) retry++;
                                if ((path[j] == 'c' || path[j] == 'C') && (path[j + 1] == 'o' || path[j + 1] == 'O') && (path[j + 2] == 'n' || path[j + 2] == 'N')) retry++;
                                if ((path[j] == 'p' || path[j] == 'P') && (path[j + 1] == 'r' || path[j + 1] == 'R') && (path[j + 2] == 'n' || path[j + 2] == 'N')) retry++;
                                if ((path[j] == 'a' || path[j] == 'A') && (path[j + 1] == 'u' || path[j + 1] == 'U') && (path[j + 2] == 'x' || path[j + 2] == 'X')) retry++;
                            }
                            if (j + 4 == miniNameSize + 1) {
                                if ((path[j] == 'c' || path[j] == 'C') && (path[j + 1] == 'o' || path[j + 1] == 'O') && (path[j + 2] == 'm' || path[j + 2] == 'M') && (path[j+ 3] == '1' || path[j + 3] == '2' || path[j + 3] == '3' || path[j + 3] == '4')) retry++;
                                if ((path[j] == 'l' || path[j] == 'L') && (path[j + 1] == 'p' || path[j + 1] == 'P') && (path[j + 2] == 't' || path[j + 2] == 'T') && (path[j + 3] == '1' || path[j + 3] == '2' || path[j + 3] == '3')) retry++;
                            }
                            if (j + 6 == miniNameSize + 1) {
                                if ((path[j] == 'c' || path[j] == 'C') && (path[j + 1] == 'l' || path[j + 1] == 'L') && (path[j+ 2] == 'o' || path[j + 2] == 'O') && (path[j + 3] == 'c' || path[j + 3] == 'C') && (path[j + 4] == 'k' || path[j + 4] == 'K') && path[j + 5] == '$') retry++;
    
                            }
                        }
                        }
                    
                    }
                numbers = numbers + (miniNameSize + 1);
                miniNameSize = 0;
                    
                }
            }
        }