使用指针与引用时函数无法获取动态数组？遇数组下标类型错误

Hey there! Let's work through your dynamic array issues step by step—this is a super common pitfall when learning to use heap-allocated arrays, so you’re not alone here.

First: What’s Causing That invalid types 'int int ' for array subscript Error? #

This error almost always boils down to a syntax mistake when accessing array elements. The compiler is seeing something like arr i (missing the [] between your pointer/array variable and index) instead of arr[i], or you’re trying to use a non-pointer/non-array type as if it were an array. For example, if you accidentally passed an int variable to your function and tried to use subscript notation on it, the compiler would throw this error because it can’t index an integer.

Since you said your capt function can print the array normally, the issue is probably isolated to another part of your code where you messed up the subscript syntax. Double-check any lines where you’re accessing array elements—look for missing brackets or mismatched variable types.

Mastering Dynamic Array Parameter Passing #

Dynamic arrays in C++ are just pointers to heap-allocated memory, so passing them to functions requires understanding how pointer and reference semantics work. Here are the two most common use cases:

1. Passing a Pointer + Array Length (For Reading/Modifying Elements) #

Pointers don’t carry length information, so you must explicitly pass the array’s size to your function. This is the standard approach when you just need to read or modify the array’s elements (not change where the pointer points).

Example code:

#include <iostream>
using namespace std;

void capt(int* arr, int size) {
    // Print array (works like you said)
    cout << "Array contents: ";
    for (int i = 0; i < size; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    // Modify an element (changes will reflect in main)
    arr[2] = 42;
}

int main() {
    int arrLength = 5;
    // Allocate dynamic array
    int* dynArr = new int[arrLength];
    
    // Initialize array
    for (int i = 0; i < arrLength; i++) {
        dynArr[i] = i + 1;
    }

    // Pass pointer and length to function
    capt(dynArr, arrLength);

    // Check modified element in main
    cout << "Modified element at index 2: " << dynArr[2] << endl;

    // Don't forget to free memory!
    delete[] dynArr;
    return 0;
}

2. Passing a Pointer Reference (For Modifying the Pointer Itself) #

If you need to change where the dynamic array pointer points (like resizing the array or reallocating memory), you need to pass a reference to the pointer. This way, changes to the pointer inside the function will affect the original pointer in main.

Example for resizing:

void resizeDynamicArray(int*& arr, int oldSize, int newSize) {
    // Allocate new larger array
    int* newArr = new int[newSize];
    
    // Copy elements from old array to new
    for (int i = 0; i < oldSize; i++) {
        newArr[i] = arr[i];
    }

    // Free old array memory
    delete[] arr;
    // Update original pointer to point to new array
    arr = newArr;
}

// In main:
int main() {
    int length = 3;
    int* dynArr = new int[length]{1,2,3};
    
    resizeDynamicArray(dynArr, length, 6);
    length = 6; // Update length variable
    
    // Now dynArr points to a 6-element array
    return 0;
}

Why Your Function Might "Not Get" the Dynamic Array #

If you’re confused why the function can’t access the array properly, here’s the key:

• Pointers don’t store array length. If you’re trying to loop through the array without passing the size, you’re probably hitting undefined behavior (even if printing seems to work sometimes).
• If you’re using regular pointer pass-by-value (not a reference) and trying to reallocate the array inside the function, you’re only modifying a copy of the pointer. The original pointer in main won’t change—hence why it feels like the function "can’t get" the updated array.

Quick Recap #

• Fix the invalid types error by checking all array subscript syntax (make sure you’re using arr[i], not arr i).
• Always pass the array length alongside the pointer when working with dynamic arrays.
• Use pointer references only when you need to modify the pointer’s address (like resizing).

内容的提问来源于stack exchange，提问作者Javier Gámez Bojórquez