#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define  _STD_WANT_LIB_EXT1_ 1
#define  Count   5
#define  buf_len  100


int main(void)
{
    char buf[buf_len] = {'0'};  // input buffer 
    int str_count = 0;          // string 1st count = 0
    int str_len = 0;            // string current length
    int outp_str_len = 0;       // output string length
    int str_max = Count;        // max count input string
    char** ptemp = NULL;
    char** ps = (char**)calloc(str_max, sizeof(char*));//5 * char* = 40 byte

    do
    {
        printf("input string you want (less than %d wards):", buf_len);
        fflush(stdin);
        char* ptest = (char*)gets_s(buf, sizeof(buf));
        if(ptest == NULL)
        {
            printf("gets_s() error\n");
            free(ps);
            ps = NULL;
            //free(ptest);
            //ptest = NULL;
            return 1;
        }
        //printf("%s\n", buf);
        else if(buf[0] == '0')
        {
            printf("You input nothing!!!\n");
            break;
        }
        else if(str_count == str_max)
        {
            str_max += str_count/4;         //add 25% merry
            ptemp = realloc(ps, str_max);
            if(ptemp == NULL)
            {
                printf("realloc() error\n");
                return 2;
            }
            ps = ptemp;
        }
        str_len = strnlen_s(buf, sizeof(buf)) + 1;// buf current length must <= buf_len
        ps[str_count] = malloc(str_len);       //allocation current merry to ps[...]
        if(ps[str_count] == NULL)
        {
            printf("error malloc() error!!!\n");
            return 3;
        }
        strcpy_s(ps[str_count++] ,str_len, buf);
        printf("Do you want to input another string? (Y/N): ");
        fflush(stdin);        
    }
    while(tolower((char)getchar()) == 'y');
    printf("%s\n", ps[str_count-1]);   //string output success
    outp_str_len = strnlen_s(ps[str_count - 1], sizeof(ps[str_count - 1]));//some errors!! sizeof() function
    if(outp_str_len == 0)
    {
        printf("strnlen() error!!!\n");
        return 4;
    }
    printf("outp_str_len = %d\n", outp_str_len); //length of string wrong
    //printf("sizeof(char*) = %zd\n", sizeof(char*));

    return 0;
        //这个程序可以输入100个字符以内的任意个数的字符串，我想用它给输入的字符串进行长度排序，程序没写完，在检查字符串长度时出错了。
        //我觉得是sizeof（）的问题。。。。
}

输出图片

粗看了一下，'0' 应该是 '\0' 等不提了

outp_str_len = strnlen_s(ps[str_count - 1], sizeof(ps[str_count - 1]));
其中 ps 是 char** 类型，因此其就等同于
outp_str_len = strnlen_s( ps[str_count-1], sizeof(char*) );
你自己想想为什么值最大只到8

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

int main(void)
{
    char board[][10] = {
                       {"123"},
                       {"4561"},
                       {"123456789"}
                      };
    //printf("board[0][0] = %c\n", board[0][0]);
    //printf("board[0]    = %s\n", board[0]);
    //printf("*board      = %s\n", *board);

    printf("lenth board[2] = %d\n", strnlen_s(board[2], sizeof(board[2])));
//这里的board 为char**型，board[ ]为char*型，我在这输出board[2]的字符串长度，这个是正确的。
//就算改成strnlen_s(board[2], sizeof(char*)也能正确输出。
//我有一个疑惑！这个程序定义的是二维数组，board类型为char**型，而我的那个字符串排序程序定义的是一个char**型指针，这有什么区别？
//我取board数组的 第i个 子数组 board[i], 这等价于指针运算 *(board + i)，这个等价是否有前提，就是首先必须定义一个二维数组。
//如果我直接定义char**指针，我逆向思维(假设上述前提非必要)，char**类型就是一个char的二维数组,
//那我字符串排序程序里的strnlen_s(ps[str_count - 1], sizeof(ps[str_count - 1]))就应该没有错误吧。
//我的字符串排序程序没有输出结果希望的结果，所以上述假设（只能定义数组，将数组视为指针，不能定义指针，将指针视为数组）为必要条件？
    return 0;
   
}

//这里的board 为char**型，board[ ]为char*型，我在这输出board[2]的字符串长度，这个是正确的。
--- 这里的board为char[4][10]类型，board[]为char[10]类型；输出当然正确了，因为 sizeof(board[2]) 等于 10 呗

//就算改成strnlen_s(board[2], sizeof(char*)也能正确输出。
--- 能正确输出 9 吗？除非你的编译器有bug

//我有一个疑惑！这个程序定义的是二维数组，board类型为char**型，而我的那个字符串排序程序定义的是一个char**型指针，这有什么区别？
--- board类型为char[4][10]，不是char**，这就是你错误的根源，下同，数组是数组，指针是指针

楼主知道sizeof是啥吗？了解过吗？百度一下很明白