-1

这是我的一些代码：我无法弄清楚如何通过 perfectTest int 传递数组。我可以选择如果 n 为 -1 则打印出它是一个不足的数字，如果 n 为 0 则打印出它是一个完美的数字，如果 n 是 1 则打印出它是一个丰富的数字编号，但我需要在其中合并数组。我需要一些提示。

//prototype
int perfectTest(int n);


//function
int perfectTest(int n)

{   bool perfect;
    int answer;
    int perfectSum = 0;
    perfect = false;

    for(int i=1; i<=n/2; i++)
    {
        if(n % i==0)
            perfectSum = i;
    }

    if(perfectSum == n)
        perfect = true;
        answer = perfectSum;
}




//main function

int main()
{
    char option;
    int  n, m;
    bool InService = true;
    char perfectTestingOption;
    int  perfectNum;
    bool perfect = true;
    int factor;


    while (InService == true)
    {
    cout << "\t\t\nWelcome! Choose an option below\n" << endl;
    cout << "A = Perfect number testing" << endl;
    cout << "B = Greatest common divisors and least common multiples" << endl;
    cout << "C = Factorization of natural numbers" << endl;
    cout << "Q = Quit the program\n" << endl;
    cout << "Enter your choice:" << endl;
    cin >> option;

    if (option == 'A' || 'a')
    {
        cout << "\t\t\nWhich option would you like?\n" << endl;
        cout << "1" << endl;
        cout << "2" << endl;
        cout << "3" << endl;
        cout << "4" << endl;
        cin >> perfectTestingOption;

        if (perfectTestingOption == '1')
        {
            cout << "Enter a positive integer to check if it is a perfect number." << endl;
            cin >> perfectNum;


        perfectTest(0);

        for( );
        if (n == -1)
        {
            cout << "That number is a deficient number" << endl;
        }

        else if (n == 0)
        {
            cout << "That number is a perfect number" << endl;
        }

        else if (n == 1)
        {
            cout << "That number is a abundant number" << endl;
        }

        else
        {
            cout << "Number is invalid" << endl;
        }
    }
4

1 回答 1

0

数组只不过是通过内存中某个基地址的偏移来寻址的数据块。如果您有基地址、元素数量和元素的数据类型，则您有足够的信息将数据视为数组。

您可以直接声明数组 -

int array[SIZE];

其中SIZE是一些整数，表示数组中的元素数。请注意，对于较大的 值，逐字声明是一个坏主意SIZE，因为这种语法在堆栈上分配数组，相对于主内存的大小，它对大小有严格的限制。

相反，您可以分配指针，然后将它们初始化为指向某个堆空间 -

int * array = new int[SIZE];

这会为整数块动态分配一些内存，并为您提供第一个“插槽”的地址。事实证明这已经足够了，因为下一位中的括号语法起到“偏移”运算符的作用。

要访问单个元素，一旦声明了数组变量：

int foo = array[idx]

idx一些int在哪里。例如，如果idxwere 等于 1（或者用文字 1 替换它，或者用计算为整数 1 的变量或表达式替换它），我们将在第一个元素“右侧”的 slot 1 槽中获取整数。回想一下，C(++) 中数组中的第一个元素的索引为 0，因为程序员很疯狂，喜欢用 0 来索引事物（并且因为括号运算符指定了从第一个元素的地址开始的偏移量）。

我们如何将数组传递给函数？如果我们知道每个数组元素的数据类型以及数组长度，则传递它们的内存地址就足够了。通过并检查数组长度非常重要！不这样做会导致可怕的后果，因为您超出了数组的边界并开始覆盖程序中的其他值。（更高级的数据结构和其他编程语言可以自动进行边界检查。由于我们使用的是裸数组，所以边界检查是我们的责任。）

现在让我们回到原来的问题。假设我们有一个函数int f(int i)可以对进来的任何东西做一些很酷的事情。我们想要“arrayify”这个函数，以便它接受数组并返回数组。

我们将利用这样一个事实，即我们确切地知道我们的数组有多长，因为在我们的例子中，输出数组的大小与输入数组的大小相同。所以我们也不必担心将这个数字从数组化函数中传递出去，尽管有一些简单的技术可以做到这一点。

我们做这样的事情：

int * __f(int * __i, int ilen)
{
    int * output = new int[ilen];
    for(int offset = 0; offset < ilen; offset++)
    {
        output[offset] = f(__i[offset]);
    }
    return output;
}

这个函数接受一个包含ilen整数的整数数组，并输出应用f到每个整数的结果。请注意，此函数会分配新的内存，稍后您将不得不这样做delete[]。通过一些简单的修改，您可以更改此函数以就地修改数组。

让我们逐行分解：

int * __f(int * __i, int ilen)

函数签名。这告诉我我将地址放入一个ilen整数数组，并将地址返回到另一个这样的数组。

    int * output = new int[ilen];

为我们的输出分配新内存。如果你完成了一块内存foo，你应该delete[] foo在完成后；否则内存将保持分配状态并占用空间，直到您的程序终止。如果您想了解更多信息，请阅读动态内存分配。

    for(int offset = 0; offset < ilen; offset++)
    {
        output[offset] = f(__i[offset]);
    }

对于我们数组中的每个元素（由offset计数器索引），我们f对输入数组的相应元素执行__i，并将数组的正确元素设置为output结果。

    return output;

最后，我们返回我们构造的数组。从技术上讲，我们返回 a int *，但这只是说“一个或多个整数的内存地址”的一种奇特方式。

*在这篇文章中，我一直在使用指针语法 ( )。对于很多人来说，对指针的深入理解需要一些时间来培养（包括我自己；我已经好几年没有“得到”指针了！）。简而言之：

  • 形式的变量int * foo包含内存地址。从语义上讲，这个内存地址被指定为指向一个int. 但实际上，地址只是一个地址。（内存地址是对应于内存中特定单元的数字。您可以将内存单元视为连续的地址；也就是说，从我们的角度来看，单元 100 与单元 101“相邻”。当我们给内存编号时，我们使用 1 字节的单元大小。较大结构的地址，如 4 字节int或 s 数组int，是第一个元素的地址。）
  • 一旦我们声明了foo， thenfoo本身就是指存储在其中的地址。如果我们想要foo指向的值，我们说*foo。在这种*情况下， 是解引用运算符：它接受一个内存地址并返回那里的内容。
  • 如果我们想要一个变量的地址bar，我们说&bar。在&这个上下文中是地址操作符：它接受一个变量并告诉你它在哪里。
  • 您可以从指针中添加和减去：foo + 3是一个完全有效的内存地址。不过要小心！您添加和减去的每个“1”都不是一个存储单元，而是多个等于数组封装的类型大小的存储单元。在我们的例子中，因为int在大多数现代平台上是 4 字节，所以foo + 3将 3*4 = 12 个内存单元添加到 的地址foo，而不是 3。
  • 指针和数组可以松散地互换。特别是foo[n]，对于任何 n 值，都可以正常工作，正如您所期望的那样。
于 2012-12-18T04:53:09.510 回答