C 分数数组

给出一系列分数，其中60分最高，36分通过。该函数将返回所有及格分数的数组

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

int* passingScores (int scores[], int size);

int main () {
    int B[] = {55, 35, 60, 25, 10, 43}; //expect display 55,60,43
    int size = 6;
    int* C;
    int i;

    C = passingScores(B, size);

    for (i=0; i<size; i++) {
        printf ("%d\n", C[i]); 
    }

    return 0;
}

#包括
#包括
int*passingScores（int分数[]，int大小）；
int main（）{
int B[]={55,35,60,25,10,43}；//期望显示55,60,43
int size=6；
int*C；
int i；
C=通过芯（B，尺寸）；
对于（i=0；i，下面的代码包括一些建议，包括添加一个额外的索引以仅跟踪及格分数，以及使用
calloc
而不是
malloc
来初始化数组。（请参阅下面的其他注释和建议的更改。）

因此，您选择性地写入该内存的某些元素的方式会将原始内容留在该内存块的某些其他区域，从而在输出结果时造成问题。

以这种方式使用
malloc
时，建议在使用前初始化内存：

pass = malloc(size * sizeof(int));
if(pass)
{
    memset(pass, 0, size*sizeof(int));
    ...

导致：

pass[0] == 0x00000000
pass[1] == 0x00000000
pass[2] == 0x00000000
pass[3] == 0x00000000
pass[4] == 0x00000000
pass[5] == 0x00000000  

使用
calloc
就像
malloc
一样分配内存，但在返回之前先清除内存，省去了使用清除内存的麻烦

另请注意，这是不必要的，也不建议这样做。
以下代码包括一些建议，包括添加额外的索引以仅跟踪及格分数，以及使用
calloc
而不是
malloc
来初始化数组。（请参阅下面的其他注释和建议的更改。）

因此，您选择性地写入该内存的某些元素的方式会将原始内容留在该内存块的某些其他区域，从而在输出结果时造成问题。

以这种方式使用
malloc
时，建议在使用前初始化内存：

pass = malloc(size * sizeof(int));
if(pass)
{
    memset(pass, 0, size*sizeof(int));
    ...

导致：

pass[0] == 0x00000000
pass[1] == 0x00000000
pass[2] == 0x00000000
pass[3] == 0x00000000
pass[4] == 0x00000000
pass[5] == 0x00000000  

使用
calloc
就像
malloc
一样分配内存，但在返回之前先清除内存，省去了使用清除内存的麻烦

另请注意，没有必要或建议这样做。
此声明存在以下问题：

 pass[i] = scores[i];

您不希望将分数复制到具有相同索引的元素中；您希望将其复制到第一个“空闲”插槽中。您需要跟踪
pass
元素的使用情况


还有第二个问题：即使及格分数较少，也要输出
size
数字

在这种情况下，我们不必将返回数组中的元素数传递给调用者，只需在末尾放置一个
0
来表示结束。但我们必须小心所有分数都通过分数的情况


第三个小问题：你认为36分是一个不及格的分数！让这成为测试中的一个教训：无论何时进行测试，都要在极限附近进行测试（所以在这种情况下，你的测试分数是35分、36分和37分）


最后，您可以动态分配一个数组，但您永远不会释放它。释放它并不重要，因为您会在退出程序之前这样做，但这是一个坏习惯。（一个可能的后果是，如果您决定使用它来帮助解决崩溃，它将导致工具（如
valgrind
）的输出变得非常嘈杂。）


#包括
#包括
int*getPassingScores（常量int*分数，整数分数）{
const int passingScore=36；
//calloc与malloc类似，但内存将
//有效地初始化为0。这意味着
//我们不需要稍后通过[j]=-1；测试。
//需要确保我们有足够的空间
//当所有的成绩都合格时！
int*pass=calloc（num_分数，sizeof（int））；
如果（！通过）
返回NULL；
for（int i=0，j=0；i=passingScore）{
通过[j++]=分数[i]；
}   
}
回程通行证；
}
内部主（空）{
智力得分[]={55,35,60,25,10,43}；
int num_分数=sizeof（分数）/sizeof（*分数）；
int*passingScores=getPassingScores（分数，num_分数）；
对于（int i=0；passingScores[i]>0；++i）{
printf（“%d\n”，passingScores[i]）；
}
免费（通行证）；
返回0；
}

当然，以下几点就足够了：

#include <stdio.h>

int main(void) {
    int scores[] = {55, 35, 60, 25, 10, 43};
    int num_scores = sizeof(scores)/sizeof(*scores);
    const int passingScore = 36;

    for (int i=0; i<num_scores; ++i)
        if (scores[i] >= passingScore)
            printf("%d\n", scores[i]);
}

#包括
内部主（空）{
智力得分[]={55,35,60,25,10,43}；
int num_分数=sizeof（分数）/sizeof（*分数）；
const int passingScore=36；
for（int i=0；i=passingScore）
printf（“%d\n”，分数[i]）；
}
此语句存在问题：

 pass[i] = scores[i];

您不希望将分数复制到具有相同索引的元素中；您希望将其复制到第一个“空闲”插槽中。您需要跟踪
pass
元素的使用情况


还有第二个问题：即使及格分数较少，也要输出
size
数字

在这种情况下，我们不必将返回数组中的元素数传递给调用者，只需在末尾放置一个
0
来表示结束。但我们必须小心所有分数都通过分数的情况


第三个小问题：你认为36分是一个不及格的分数！让这成为测试中的一个教训：无论何时进行测试，都要在极限附近进行测试（所以在这种情况下，你的测试分数是35分、36分和37分）


最后，您可以动态分配一个数组，但您永远不会释放它。释放它并不重要，因为您会在退出程序之前这样做，但这是一个坏习惯。（一个可能的后果是，如果您决定使用它来帮助解决崩溃，它将导致工具（如
valgrind
）的输出变得非常嘈杂。）


#包括
#包括
int*getPassingScores（常量int*分数，整数分数）{
const int passingScore=36；
//calloc与malloc类似，但内存将
//有效地初始化为0。这意味着
//我们不需要
#include <stdio.h>

int main(void) {
    int scores[] = {55, 35, 60, 25, 10, 43};
    int num_scores = sizeof(scores)/sizeof(*scores);
    const int passingScore = 36;

    for (int i=0; i<num_scores; ++i)
        if (scores[i] >= passingScore)
            printf("%d\n", scores[i]);
}

int main( void )

int size = 6;

const int scores[]

int passingScore = 36;

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

size_t passingScores( const int scores[], size_t size, int passingScore, int **passed );

int main( void ) 
{
    int scores[] = { 55, 35, 60, 25, 10, 43 };
    const size_t SIZE = sizeof( scores ) / sizeof( *scores );
    int passingScore = 36;

    int *passed_scores = NULL;

    size_t n = passingScores( scores, SIZE, passingScore, &passed_scores );

    for ( size_t i = 0; i < n; i++ ) 
    {
        printf( "%d ", passed_scores[i] ); 
    }
    putchar( '\n' );

    free( passed_scores );

    return 0;
}

size_t passingScores( const int scores[], size_t size, int passingScore, int **passed )
{
    size_t n = 0;

    for ( size_t i = 0; i < size; i++ )
    {
        n += passingScore < scores[i];
    }

    if ( n != 0 )
    {
        *passed = malloc( n * sizeof( int ) );  

        if ( *passed != NULL )
        {
            for ( size_t i = 0, j = 0; i < size; i++ )
            {
                if ( passingScore < scores[i] ) ( *passed )[j++] = scores[i];
            }
        }
    }       

    return n;
}   

55 60 43