计算数组的max元素的位置。函数返回max元素。通过指针和pos传递数组。通过引用

Question

我的大学作业有点问题。我真的不明白指针和引用是怎么回事。有人能指出我哪里出错了吗？？

using namespace std;
int i, n, maax, *position;
void tablica()
{
    int tab[n];
    cout<<"enter data:"<<endl;
    for (i=0; i<n; i++)
    {
        cin>>tab[i];
    }
    maax = tab[0];
    for (i=0; i<n; i++)
    {
        if (maax<tab[i])
        {
            maax=tab[i];
            *position=i+1;
        }
    }
}

int main()
{
    cout<<"array size:"<<endl;
    cin>>n;
    tablica();
    cout<<"max el. position is: "<<&position<<endl;
    return 0;
}

Answer 1

匿名用户

看看这个函数应该做什么：

函数返回max元素。通过指针和pos传递数组。通过引用”

它不应该读取任何数组元素。< br >它不应该接收或返回全局变量中的值。< br >它不应该使用指向该位置的指针。

它应该传递一个数组（作为指针）和存储最大位置（作为参考）并在某个地方，并返回最大值。

也就是它的原型应该是这样的

int tablica(const int* input, int size, int& max_position)

main应该是这样的：

int main()
{
    int n = 0;
    cout << "Array size: " << endl;
    cin >> n;
    int* data = new int[n];
    for (int i = 0; i < n; i++)
    {
        cin >> data[i];   
    }
    int position = -1;
    int max_element = tablica(data, n, position);
    cout << "The maximum element is " << max_element << ", at index " << position << endl;
    delete [] data;
}

将实现< code>tablica作为练习。

Answer 2

不应使用全局变量（请参阅全局变量不好吗？）。int tab[n];不是标准的 C ，它是一个可变长度数组，在某些编译器上只能作为扩展（请参阅为什么可变长度数组不是 C 标准的一部分？）。segfault 是因为你从不为该位置分配内存，它被初始化是因为它是一个全局的，但它不指向一个 int（请参阅根据标准，取消引用等于 nullptr 的指针是否未定义行为？）。

您不需要任何数组来获取最大值和位置。而且无需在代码中使用指针。确定读取输入的同一循环中的最大值和位置，并从函数返回结果，而不是使用全局变量：

#include <iostream>

int tablica(int n) {
    std::cout<<"enter data:\n";
    
    int max = 0;
    int max_pos = 0;
    std::cin >> max;
    
    for (int i=1; i<n; i++) {
        int number = 0;
        std::cin>>number;        
        if (max<number) {
            max=number;
            max_pos = i;
        }
    }
    return max_pos;
}

int main()
{
    std::cout<<"input size:\n";
    int n;
    std::cin>>n;
    int position = tablica(n);
    std::cout<<"max el. position is: "<< position << "\n";
    return 0;
}

Answer 3

当然，我们可以帮你一点忙。但是，关于指针和引用的整个主题不能在SO的简短答案中涵盖。你需要读一本书。

以下内容将非常简单，实际上还有更多内容。但让我们从这个简单的解释开始。

让我给你一个在C或非常早期的C书籍中经常使用的典型例子。看看应该交换2个变量值的函数交换。

#include <iostream>

void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int a = 1, b = 2;
    swap(a, b);
    std::cout << "a: " << a << "\tb: " << b << '\n';
}

我们希望在调用函数交换后，“a”将包含 2，“b”将包含 1。但事实并非如此。因为在这种情况下（并且默认情况下），提供给函数交换的变量是按值传递的。因此，编译器将生成一些代码，并将变量“a”和“b”的值复制到一些本地内部存储中，也可以使用名称“a”和“b”进行访问。因此，原来的“a”和“b”永远不会被触及或修改。通过按值传递变量，副本将是 mdae。这通常是有意为之，但在此示例中不起作用。

下一个发展阶段是指针。指针也是一个包含值的变量。但这一次，它是内存中另一个变量的地址。如果你有一个像< code>int a=3这样的变量；然后，3存储在内存中的某个位置(由链接器的编译器决定)，您可以访问名为“a”的内存区域。

指针可以存储这个变量的内存地址。所以不是变量“a”的值3，而是变量“a”在内存中的地址。指针指向存储3的内存区域。如果你想访问这个值，那么你需要用*运算符取消引用指针。要获取变量“a”的地址，你可以写

它间接地帮助你从一个函数中获得修改后的值或结果值。示例:

#include <iostream>

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int a = 1, b = 2;
    swap(&a, &b);
    std::cout << "a: " << a << "\tb: " << b << '\n';
}

在main中，我们获取变量“a”和“b”的地址，并将其赋予函数。函数的地址（指针）现在将作为值提供给函数。指针的副本将被制作（实际上不是），但这并没有坏处，因为我们现在可以通过对指针进行去重标来修改变量的原始值。然后函数结束，我们将在原始变量“a”和“b”中找到正确的值。

但是，众所周知，指针很难理解并且非常容易出错。因此，“参考”被发明了。它是普通变量的别名。好的一点是，如果你传递对函数的引用，那么你可以立即修改原始值。这使得事情变得非常方便。

然后可以将功能交换写为

#include <iostream>

void swap(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int a = 1, b = 2;
    swap(a, b);
    std::cout << "a: " << a << "\tb: " << b << '\n';
}

这给出了预期的结果。并且简单得多。

现在谈谈你的代码。首先，VLA（可变长度数组），即int选项卡[n]；其中“n”不是编译时间常量，不是C语言的一部分。你不能使用它们。你可以也应该使用std::向量，但你还没有了解它。所以我们将使用new来动态分配一些内存。请注意：实际上，不应该使用new、拥有内存的原始指针和C-Style数组。但无论如何。

那就让我们看看你的要求

函数返回max元素。通过指针传递数组，通过引用传递位置

因此，我们需要一个函数来计算数组中的最大元素，然后返回此值，并另外复制变量中最大元素的位置，作为参考提供给函数。我们将为数组的大小添加一个附加参数，因为我们不会在此处使用 VLA。该数组将由指针给出。

因此，函数的原型将是：

int getMaxElement(int *array, int sizeOfArray, int& positionOfMaxValue)

为了实现这样一个函数，我们创建一个内部变量来保存最大值，稍后我们将返回这个值。然后，我们将循环中的所有值与这个最大值进行比较，如果我们找到一个更大的值，那么我们存储这个新的结果。作为初始值，我们可以简单地取数组的第一个值。

例子：

#include <iostream>

int getMaxElement(int* array, int sizeOfArray, int& positionOfMaxValue) {
    int resultingMaxValue = 0;
    if (sizeOfArray > 0) {
        resultingMaxValue = array[0];

        for (int i = 0; i < sizeOfArray; ++i) {
            if (array[i] > resultingMaxValue) {
                resultingMaxValue = array[i];
                positionOfMaxValue = i;
            }
        }
    }
    return resultingMaxValue;
}


int main() {
    // Get array size from user
    std::cout << "\nPlease enter the array size:  ";
    int arraySize = 0;
    std::cin >> arraySize;

    // Create an array
    int* array = new int[arraySize];

    // Read all values into the array
    for (int i = 0; i < arraySize; ++i)
        std::cin >> array[i];

    // Now calculate the max value and position of the max value
    int position = 0;
    int maxValue = getMaxElement(array, arraySize, position);

    // Show result
    std::cout << "\n\nResult:\nThe maximum value '" << maxValue << "' is at position " << position << '\n';

    delete[] array;
}

请记住:这是一个非常简化的解释