不使用sizeof在C程序中动态查找数组长度

我试图读取一个文件并仅存储数组中的数字

我的例子是file.csv

“1”、“2”、“3”
"1","4","6","7"
"12","15"

请不要建议这些解决方案

sizeof（arr）/sizeof（arr[0]）

或

*（&arr+1）-arr

因为这两个函数都没有给出包含实际值的数组的长度。它只是在声明数组时给出数组的长度。我想知道当实际值存在时，在运行时数组的长度

问题陈述：在每一行中找到numOfwords（出现在 代码注释）

我的代码如下：

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>


int main(int argc, char *argv[])
{
    int i = 0, j = 0, k = 0;
    char literal, string[4][10][4];
    char *filename = "file.csv";
    FILE *f;

    f = fopen(filename, "r");
    while ((literal = getc(f)) != EOF) {
      if (isdigit(literal)) {
        string[i][j][k] = literal;
        k++;
      } else {
        if (k > 0) {
          string[i][j][k] = '\0';
        }
        k = 0;
      }
      if (literal == ',') j++;
      if (literal == '\n') i++, j = 0;
    }

  int numOfLines = i;
  int total = 0;
  for (int p = 0; p < numOfLines; p++) {
    // int numOfWords = *(&string[p] + 1) - string[p]; // Returns 10
    // int numOfWords = sizeof(string[p]) / sizeof(string[p][0]);  // Returns 10
    // 
    // The Problem Statement: Find the numOfwords in each line.
    printf("numOfWords in line %p: %d\n", numOfWords);
    for (long int q = 0; q < numOfWords; q++) {
      /* code */
      total += atoi(string[p][q]);
    }
  }
  printf("Sum = %d", total);
}

#包括
#包括
#包括
#包括
int main（int argc，char*argv[]）
{
int i=0，j=0，k=0；
字符文字，字符串[4][10][4]；
char*filename=“file.csv”；
文件*f；
f=fopen（文件名，“r”）；
while（（literal=getc（f））！=EOF）{
if（isdigit（文字））{
字符串[i][j][k]=文字；
k++；
}否则{
如果（k>0）{
字符串[i][j][k]='\0'；
}
k=0；
}
如果（文字=='，'）j++；
如果（literal=='\n'）i++，j=0；
}
int numOfLines=i；
int-total=0；
对于（int p=0；p

任何比此代码更好的解决方案都将受到赞赏

输出：

第1行中的单词数：3 第2行的单词数：4 第3行的单词数：2 总和=51

---

您必须自己跟踪在阵列中放置的元素数量。没有别的办法。

也许：

typedef struct 
{
    size_t size;
    size_t elementsize;
    unsigned char array[];
}myarray;

myarray *MA_Init(void)
{
    myarray *arr = calloc(1, sizeof(*arr));
    return arr;
}

myarray *MA_alloc(myarray *arr, size_t nelem, size_t elemsize)
{
    narr = realloc(arr, nelem * elemsize + sizeof(*narr));
    if(narray)
    {
        narray -> size = nelem;
        narray -> elementsize = elemsize;
    }
    return narr;
}

int MA_Set(myarray *arr, size_t index, void *elem)
{
    int result = !arr;
    result = result && (index < arr -> size);
    if(result)
    {
        memcpy(&arr -> array[index * arr -> elementsize], elem, arr -> elementsize);
    }

    return result;
}

int MA_Get(myarray *arr, size_t index, void *elem)
{
    int result = !arr;
    result = result && (index < arr -> size);
    if(result)
    {
        memcpy(elem, &arr -> array[index * arr -> elementsize], arr -> elementsize);
    }

    return result;
}

typedef结构
{
大小；
大小元素大小；
无符号字符数组[]；
}myarray；
myarray*MA_Init（无效）
{
myarray*arr=calloc（1，sizeof（*arr））；
返回arr；
}
myarray*MA_alloc（myarray*arr、size_t nelem、size_t elemsize）
{
narr=realloc（arr，nelem*elemsize+sizeof（*narr））；
如果（narray）
{
narray->size=nelem；
narray->elementsize=elemsize；
}
返回narr；
}
整数集（myarray*arr、大小索引、void*elem）
{
int结果=！arr；
结果=结果&（索引size）；
如果（结果）
{
memcpy（&arr->array[index*arr->elementsize]，elem，arr->elementsize）；
}
返回结果；
}
int-MA_-Get（myarray*arr、size_-t索引、void*elem）
{
int结果=！arr；
结果=结果&（索引size）；
如果（结果）
{
memcpy（elem，&arr->array[index*arr->elementsize]，arr->elementsize）；
}
返回结果；
}

。。。

---

等等……

听起来像是一份工作，因为我不明白这个问题。您读取一些内容，然后将其存储在数组中。因此，每次执行此操作时都要进行计数……数组的大小与“实际值”的存在无关，而只与所声明数组的大小有关。

sizeof

运算符在编译时生成此值，除非操作数是VLA，在这种情况下，在运行时对其求值。但如果您想知道一个数组包含多少“有意义”的值，可能需要包含一个sentinel值。。。而（（literal=getc（f））！=EOF）{在

char

无符号时是一个无限循环，在

char

有符号且读取

（char）EOF

时是不充分的。使用

int literal；

数组大小在C中是常量，一旦定义。

char literal，string[4][4]；

始终是一个包含

字符的4x10x4数组。内容与此无关。通过扩展，您可以在读入这些值时缓存这些值，为每个
i
保存最大值
j
，或者您可以在运行时通过扫描适当的数组并计算有效元素来进行计算。DV和无注释？无否决权但是我被你的解释和你回答的自信所吸引。