是否可能存在不会导致程序崩溃的内存问题？

问题描述 投票：1回答：1

我写了一个文本密码程序。它似乎适用于几个字符长的文本字符串，但不适用于较长的字符串。它通过从文本文件中读取来获取输入文本。在较长的文本字符串上，它仍然可以在不崩溃的情况下运行，但它似乎无法正常工作。

下面我已经隔离了执行该文本加扰的代码。如果它有用，我在运行Ubuntu 19.04的虚拟机中运行它。运行代码时，在提示时输入auto。我删除了其余的代码，所以它不会太长。

#include <iostream>
#include <string>
#include <sstream>
#include <random>
#include <cmath>
#include <cctype>
#include <chrono>
#include <fstream>
#include <new>


bool run_cypher(char (&a)[27],char (&b)[27],char (&c)[11],char (&aa)[27],char (&bb)[27],char (&cc)[11]) {
//lowercase cypher, uppercase cypher, number cypher, lowercase original sequence, uppercase original sequence, number original sequence
std::ifstream out_buffer("text.txt",std::ios::in);
std::ofstream file_buffer("text_out.txt",std::ios::out);
//out_buffer.open();
out_buffer.seekg(0,out_buffer.end);
std::cout << "size of text: " << out_buffer.tellg() << std::endl;//debug
const int size = out_buffer.tellg();
std::cout << "size: " << size << std::endl;//debug
out_buffer.seekg(0,out_buffer.beg);
char *out_array = new char[size + 1];
std::cout << "size of out array: " << sizeof(out_array) << std::endl;//debug
    for (int u = 0;u <= size;u = u + 1) {
    out_array[u] = 0;
    }
out_buffer.read(out_array,size);
out_buffer.close();
char original[size + 1];//debug
    for (int bn = 0;bn <= size;bn = bn + 1) {//debug
    original[bn] = out_array[bn];//debug
    }//debug
    for (int y = 0;y <= size - 1;y = y + 1) {
    std::cout << "- - - - - - - -" << std::endl;
    std::cout << "out_array[" << y << "]: " << out_array[y] << std::endl;//debug
    int match;
    int case_n; //0 = lowercase, 1 = uppercase
        if (isalpha(out_array[y])) {
            if (islower(out_array[y])) {
            //std::cout << "out_array[" << y << "]: " << out_array[y] << std::endl;//debug
            //int match;
                for (int ab = 0;ab <= size - 1;ab = ab + 1) {
                    if (out_array[y] == aa[ab]) {
                    match = ab;
                    case_n = 0;
                    std::cout << "matched letter: " << aa[match] << std::endl;//debug
                    std::cout << "letter index: " << match << std::endl;//debug
                    std::cout << "case_n: " << case_n << std::endl;//debug
                    }
                }
            }
            if (isupper(out_array[y])) {
                for (int cv = 0;cv <= size - 1;cv = cv + 1) {
                    if (out_array[y] == bb[cv]) {
                    case_n = 1;
                    match = cv;
                    std::cout << "matched letter: " << bb[match] << std::endl;//debug
                    std::cout << "letter index: " << match << std::endl;//debug
                    std::cout << "case_n: " << case_n << std::endl;//debug
                    }
                }
            }
            if (case_n == 0) {
            out_array[y] = a[match];
            std::cout << "replacement letter: " << a[match] << " | new character: " << out_array[y] << std::endl;//debug
            }
            if (case_n == 1) {
            std::cout << "replacement letter: " << b[match] << " | new character: " << out_array[y] << std::endl;//debug
            out_array[y] = b[match];
            }

        }
        if (isdigit(out_array[y])) {
            for (int o = 0;o <= size - 1;o = o + 1) {
                if (out_array[y] == cc[o]) {
                match = o;
                std::cout << "matched letter: " << cc[match] << std::endl;//debug
                std::cout << "letter index: " << match << std::endl;//debug
                }
            }
        out_array[y] = c[match];
        std::cout << "replacement number: " << c[match] << " | new character: " << out_array[y] << std::endl;//debug
        }
    std::cout << "- - - - - - - -" << std::endl;
    }
std::cout << "original text: " << "\n" << original << "\n" << std::endl;    
std::cout << "encrypted text: " << "\n" << out_array << std::endl;
delete[] out_array;
return 0;
}

int main() {
const int alpha_size = 27;
const int num_size = 11;
char l_a_set[] = "abcdefghijklmnopqrstuvwxyz";
char cap_a_set[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char n_a_set[] = "0123456789";
std::cout << "sizeof alpha_set: " << std::endl;//debug
char lower[alpha_size] = "mnbvcxzasdfghjklpoiuytrewq";
char upper[alpha_size] = "POIUYTREWQASDFGHJKLMNBVCXZ";
char num[num_size] = "9876543210"; 
int p_run; //control variable. 1 == running, 0 == not running
int b[alpha_size]; //array with values expressed as index numbers
std::string mode;
int m_set = 1;
    while (m_set == 1) {
    std::cout << "Enter 'auto' for automatic cypher generation." << std::endl;
    std::cout << "Enter 'manual' to manually enter in a cypher. " << std::endl;
    std::cin >> mode;
    std::cin.ignore(1);
    std::cin.clear();
        if (mode == "auto") {
        p_run = 2;
        m_set = 0;
        }
        if (mode == "manual") {
        p_run = 3;
        m_set = 0;
        }
    }
    if (p_run == 2) { //automatic mode
    std::cout <<"lower cypher: " << lower << "\n" << "upper cypher: " << upper << "\n" << "number cypher: " << num << std::endl;//debug
    run_cypher(lower,upper,num,l_a_set,cap_a_set,n_a_set);
    return 0;//debug
    }
    while (p_run == 3) {//manual mode
    return 0;//debug    
    }
return 0;
}

例如，使用包含“mnbvcxzasdfghjklpoiuytrewq”的数组作为小写字母的密码，如果输入是“abcd”，我会得到“mnbv”。这是对的。

如果输入是“长字”，那么当它应该是“m gkjz rkov”时，我将“m gggz zzzv”作为输出。排序正确但仍然错误。如果我使用“这是一个非常长的句子会导致程序失败”作为输入，我得到“uas”作为输出，这是完全错误的。程序仍然运行，但它无法按预期运行。所以正如你所看到的那样，它确实有效，但对远程长的任何文本字符串都没有。这是一个内存问题还是我在某个地方犯了一个可怕的错误？

c++
1个回答
3
投票

对于您的特定代码，您应该通过内存检查工具（如valgrind）运行它，或使用address sanitizer.进行编译

以下是一些内存问题的示例，这些问题很可能不会导致程序崩溃：

  1. 忘记删除一个在程序中只分配一次的小对象。如果内存泄漏不会导致程序内存不足，则内存泄漏可能会持续数十年未被发现。
  2. 从已分配的未初始化内存中读取。如果系统在第一次写入时懒惰地分配对象，则可能仍会崩溃。
  3. 在堆上的对象之后稍微写出边界，其大小为sizeof(obj) % 8 != 0。这是如此，因为堆分配通常以8或16的倍数完成。您可以阅读它at answers of this SO question。
  4. 取消引用nullptr不会在某些系统上崩溃。例如，AIX用于将零置于地址0x0处和附近。较新的AIX可能仍然会这样做。 在许多没有内存管理的系统上，地址零是常规内存地址或内存映射寄存器。可以访问此内存而不会崩溃。 在我尝试的任何系统（基于POSIX）上，可以通过内存映射在地址0处分配有效内存。这样做甚至可以通过nullptr写作而不会崩溃。

这只是部分清单。

注意：这些内存问题是未定义的行为。这意味着即使程序在调试模式下没有崩溃，编译器也可能在优化期间假设错误。如果编译器假定错误，它可能会创建一个在优化后崩溃的优化代码。

例如，大多数编译器都会对此进行优化：

int a = *p; // implies that p != nullptr
if (p) 
   boom(p);

进入：

int a = *p;
boom(p);

如果系统允许解除引用nullptr，则此代码可能会在优化后崩溃。它不会因解除引用而崩溃，但是因为优化做了程序员没有预见到的事情。

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.