C++11 c++；

我在将数组（在这个特殊情况下是char数组）乘以一个值时遇到了一些问题。 我的代码如下所示：

char* tab1 = copy("11");
char t = '2';
int length = strlen(tab1) + 2;
char*result = populate('0', length);
int p_length = strlen(tab1);
for (int j = p_length - 1; j >= 0; j--) {
    char* tmp = multiply_chars(tab1[j], t);
    v_shove(tmp, j);
    char* tmp2 = add_tables(result, tmp);
    delete[] result;
    result = tmp2;
    delete[] tmp;
}
cout << result << endl;
delete[] result;
delete[] tab1;

部分，但不知道为什么会发生。 我通过在无限循环中运行代码片段并检查内存使用情况来检查泄漏。 任何帮助都将不胜感激！如果需要的话，我会发布所用方法的代码，但为了简洁起见，我决定不在这里发布。他们都归还新戒指。另外，t2变量是在我检查数组逐数组乘法时出现的，这也泄露了-决定先进行数组逐值乘法。 （现在，说实话，这是学校项目所需的方法之一，但这只是其中的一个很小的部分，我想如果我问一下也不会有什么坏处——老师并不是很热衷于帮助解决特定的代码问题）

功能包括：

char * add_tables(const char * table1, const char * table2)
{
    char* tmp1 = get_string_trailing("0",table1);
    char* tmp2 = get_string_trailing("0", table2);
    int l1 = strlen(tmp1), l2 = strlen(tmp2);
    if (l1 != l2) {
        if (l1 > l2) {
            char* t = resize_string(tmp2, l1 - l2, '0');
            delete[] tmp2;
            tmp2 = t;
        }
        else {
            char* t = resize_string(tmp1, l2 - l1, '0');
            delete[] tmp1;
            tmp1 = t;
        }
}
    int length = strlen(tmp1) + 2;
    char*result = new char[length];
    result[length - 1] = 0;
    int buffer = 0;
    for (int i = length - 2; i > 0; i--) {
        int t = buffer + (tmp1[i-1]-'0') + (tmp2[i-1]-'0');
        result[i] = (t% 10)+'0';
        buffer = (t - (t % 10))/10;
    }
    result[0] = buffer + '0';
    char* t = get_string_trailing("0", result);
    delete[]result;
    result = t;
    delete[]tmp1;
    delete[]tmp2;
    return result;
}
void v_shove(char *&c, int i)
{
    char* tmp = shove(c, i);
    delete[] c;
    c = tmp;
}
char * populate(const char populator, int length)
{
    char* result = new char[length + 1];
    result[length] = 0;
    for (int i = 0; i < length; i++) {
        result[i] = populator;
    }
    return result;
}
char * multiply_chars(const char c1,const char c2)
{
    char*result = new char[3];
    result[2] = 0;
    char tmp1 = c1 - '0', tmp2 = c2 - '0';
    result[1] = (tmp1*tmp2 % 10) + '0';
    result[0] = (tmp1*tmp2 - (tmp1*tmp2 % 10)) / 10 + '0';
    char* r = get_string_trailing("0", result);
    delete[] result;
    result = r;
    return result;
}
int get_length_trailing(const char * ignore,const char * table)
{
    int length = 0;
    int i = 0;
    bool flag = true;
    while (i < strlen(table)) {
        if (flag) {
            for (int j = 0; j < strlen(ignore); j++)
            if (table[i] == ignore[j])goto BREAKPOINT;
        }
        flag = false;
        length++;
    BREAKPOINT:i++;
    }
    return length;
}
char * get_string_trailing(const char * ignore,const char * table)
{
    int result_length = get_length_trailing(ignore, table);
    char* result = new char[result_length + 1];
    int counter = 0;
    int i = 0;
    bool flag = true;
    while (i < strlen(table)) {
        if (flag)
            for (int j = 0; j < strlen(ignore); j++)
                if (table[i] == ignore[j])goto BREAKPOINT;
        flag = false;
        result[counter] = table[i];
        counter++;
    BREAKPOINT:i++;
    }
    result[result_length] = 0;
    if (result_length == 0) return copy("0");
    return result;
}
char * shove(const char * table1, int index)
{
    char*result = "0";
    int length = strlen(table1) + index + 1;
    result = new char[length];
    result[length - 1] = 0;
    if (index > 0) {
        for (int i = 0; i < strlen(table1); i++)
            result[i] = table1[i];
        for (int i = 0; i < index; i++)
            result[strlen(table1) + i] = '0';
    }
    else {
        for (int i = 0; i < strlen(result); i++)
            result[i] = table1[i];
    }
    char* t = get_string_trailing("0", result);
    delete[] result;
    result = t;
    return result;
}

char*add_表（const char*table1，const char*table2）
{
char*tmp1=获取字符串尾随（“0”，表1）；
char*tmp2=获取字符串尾随（“0”，表2）；
int l1=strlen（tmp1），l2=strlen（tmp2）；
如果（l1！=l2）{
如果（l1>l2）{
char*t=resize_字符串（tmp2，l1-l2，'0'）；
删除[]tmp2；
tmp2=t；
}
否则{
char*t=resize_字符串（tmp1，l2-l1，'0'）；
删除[]tmp1；
tmp1=t；
}
}
int-length=strlen（tmp1）+2；
字符*结果=新字符[长度]；
结果[长度-1]=0；
int缓冲区=0；
对于（int i=长度-2；i>0；i--）{
int t=buffer+（tmp1[i-1]-'0'）+（tmp2[i-1]-'0'）；
结果[i]=（t%10）+'0'；
缓冲区=（t-（t%10））/10；
}
结果[0]=缓冲区+0'；
char*t=获取字符串尾随（“0”，结果）；
删除[]结果；
结果=t；
删除[]tmp1；
删除[]tmp2；
返回结果；
}
无效v_推力（字符*&c，内部i）
{
char*tmp=推（c，i）；
删除[]c；
c=tmp；
}
字符*填充（常量字符填充器，整数长度）
{
字符*结果=新字符[长度+1]；
结果[长度]=0；
for（int i=0；i0）{
对于（int i=0；i

在

get\u string\u trailing

中至少存在内存泄漏：如果

result\u length

为零，则返回一个副本，而不删除

result

。

“string”

（例如

“0”

）和

“char”

）之间也存在混淆：使用双引号，终止字符串字符（

\0

）将自动附加到字符串，而简单引号仅定义字符。所以

“0”

是由内存中的2

字符组成的，不能存储在指针中（未定义的行为，覆盖内存）

总结：这里是C，不是学习C++。如果你必须处理C字符串（你在C中写了一个低级的导频，或者你的教授仍然不理解C和C++是不同的语言），那么至少使用<代码>字符串。H< /Cube >（C）/<代码> cString < /Cube >（C++中），以减少内存泄漏或未定义行为的可能性。如果不必使用C字符串，请使用标准库中的
std:：string
和字符串操作工具。您的工作将更加轻松，您的代码不易受到bug的攻击：

#include <string>
#include <iostream> 
using namespace std;

int main()
{
  string tab1("11")
  string t("2") // never use the single quotes for a string
  cout << stoi(tab1) * stoi(t) << endl;
  return;
}

#包括
#包括
使用名称空间std；
int main（）
{
字符串tab1（“11”）
字符串t（“2”）//切勿对字符串使用单引号
你能试着创建一个并向我们展示吗？如果没有它，你将无法帮助你。另外，如果你有一个内存调试器（例如）然后使用它，如果你没有，那么就得到一个。另外，你怎么知道你有内存泄漏？你现在怎么检查它？似乎导致泄漏的原因很模糊。是的，先生，我认为这是，不幸的是，我可以发布的最小的片段，添加了所有必需的函数。如果它不可读，我很抱歉-我还是一个初学者，这真的是博格我通过查看VisualStudio-I中的内存使用情况来检查是否存在泄漏
#include <string>
#include <iostream> 
using namespace std;

int main()
{
  string tab1("11")
  string t("2") // never use the single quotes for a string
  cout << stoi(tab1) * stoi(t) << endl;
  return;
}