傳遞給C中的函數時擦除指針數組的內容

Question

因此，我先從文本文件加載浮點數行，然后將它們存儲在指針數組中，然后再將它們保存回文本文件並添加對其大小的引用。 文本文件中值的數量各不相同，因此數組必須是動態的。 我像這樣在main中定義指針數組。

size_t size = (int)100 * sizeof(float);
float * val = malloc(size);

然后，我將指針數組傳遞給加載文本文件並將其保存值的函數，如下所示。

//Read file into array.
int readFile(float *val, int size) {

char buf[20] = { 0 };
val[0] = 0;
double temp = 0;
int i = 1;
FILE *file;
file = fopen("C:\\Users\\MoldOffice\\Dropbox\\VS\\finalproj\\ecgproject\\dataStream", "r");
if (!file) {
    printf("Coulding find file.\n");
    exit(1);
}

while (fgets(buf, 20, file) != NULL) {
    temp = atof(buf);
    if (temp != 0) {
        // Increment i to find the size of the useful data.
        val[i] = temp;
        //printf("%d",val[i]);
        i++;
        if (i == size / sizeof(float)) {
            size += 100*sizeof(float);
            double* val_temp = realloc(val, size);
            if (val_temp == NULL) {
                printf("Realloc failed.\n");
            }
            else {
                val = val_temp;
            }
        }
    }
}
//Test that the array is readable.
for (int i = 0; i < 5; i++) printf("val[%d]=%f\n", i, val[i]);

return(i);
fclose(file);

這可以正常工作，當我在main中將指針數組的內容打印回去時，它可以工作。 然后，我將相同的指針數組傳遞給另一個函數，該函數將數組和第一行的大小保存在一個新的文本文件中，問題是當我第二次傳遞指針數組時，內容已更改（大部分是0（帶有一些隨機數）。 我完全不知道為什么會這樣。 寫入文件的功能在這里：

// Write file into array.
void writeFile(float *val,int size) {

printf("%d",sizeof(val));
FILE *file;
int sampleNum;
char buf[10];
file = fopen("sampleNum.txt", "r");
if (file == NULL) { sampleNum = 0; }
else { fscanf(file, "%d", &sampleNum); printf("%d",sampleNum);}
char fileString[10];
sprintf(fileString,"sample%d\0", sampleNum);
file = fopen(fileString, "w");

//Test that the array is readable.
for (int i = 0; i < 5; i++) printf("val[%d]=%f\n", i, val[i]);

//Print the array to a text file and save.
fprintf(file, "%d\n", size);
for (int i = 1; i < size; i++) {
    fprintf(file, "%f\n", val[i]); 
    printf("%f\n", val[i]); }
fclose(file);
}

主要的其余部分可以在這里找到：

int main() {

size_t size = (int)100 * sizeof(float);
float * val = malloc(size);

// Read the data into an array.
int arraySize = readFile(val, size);

//Test that the array is readable.
for (int i = 0; i < 5; i++) printf("val[%d]=%f\n", i, val[i]);

// Save the array to a text file, with the size of the array as the first element.
writeFile(val,arraySize);

}

Answer 1

        double* val_temp = realloc(val, size);
        if (val_temp == NULL) {
            printf("Realloc failed.\n");
        }
        else {
            val = val_temp;

此函數的調用者無法知道您已將數組移至其他位置。 它仍然有舊的，現在無效的指針。

您在size也有類似的問題。 呼叫者如何知道您進行了更改？

您選擇的責任划分很差。 如果調用方負責分配緩沖區，則此函數應要求調用方擴大緩沖區。 如果此函數負責分配緩沖區，則應分配它。 分散管理一塊內存分配的責任通常是一個非常糟糕的主意，這顯示了原因之一。

也許傳入一個指向包含緩沖區及其大小的指針的結構的指針？ 可以，但是仍然顯示責任分工不佳。

也許此函數分配了緩沖區並返回了一個結構，該結構包含一個指向它的指針以及其中的元素數？

如果您確實想以這種方式執行操作，請考慮將函數的指針傳遞給結構，該結構包括指向數組的指針，數組的大小以及指向用於調整數組大小的函數的指針。 當然，調用者可以將此指針設置為指向realloc函數（盡管最好是將其更改為結構的指針和大小成員的函數）。

您還可以使用如下代碼：

struct float_buffer
{
    float* buffer;
    int size;
};

struct float_buffer allocate_float_buffer(int size)
{
    struct float_buffer buf;
    buf.buffer = malloc (size * sizeof(float));
    buf.size = size;
    return buf;
}

bool resize_float_buffer(struct float_buffer* buf, int size)
{
    float* tmp = realloc(buf->buffer, size * sizeof(float));
    if (tmp == NULL)
        return false;
    buf->buffer = tmp;
    buf->size = size;
    return true;
}

然后向函數傳遞一個struct float_buffer * 。