图形和函数图像的绘制

图形和函数图像的绘制

本章详细讨论如何使用C语言绘制出各种规则的图形和一些常见函数的图像。  

 

一、    使用所见即所得的方法绘制

    直接上代码：

1. /* 
2.  * 所见即所得的绘制方法 
3.  * 缺点：不灵活、不易修改 
4.  * 优点：直观、简单 
5.  */  
6. #include <stdio.h>  
7.   
8. int main ( void )  
9. {  
10.     // 绘制正方形  
11.     printf ( "\n" );  
12.     printf ( "*  *  *  *  *  \n"  
13.          "*  *  *  *  *  \n"  
14.          "*  *  *  *  *  \n"  
15.          "*  *  *  *  *  \n"  
16.          "*  *  *  *  *  \n" );  
17.   
18.     // 绘制长方形  
19.     printf ( "\n" );  
20.     printf ( "*  *  *  *  *  \n"  
21.          "*  *  *  *  *  \n"  
22.          "*  *  *  *  *  \n" );  
23.   
24.     // 绘制直角三角形  
25.     printf ( "\n" );  
26.     printf ( "*  *  *  *  *  \n"  
27.          "*  *  *  *     \n"  
28.          "*  *  *        \n"  
29.          "*  *           \n"  
30.          "*              \n" );  
31.   
32.     // 绘制菱形  
33.     printf ( "\n" );  
34.     printf ( "      *        \n"  
35.          "   *  *  *     \n"  
36.          "*  *  *  *  *  \n"  
37.          "   *  *  *     \n"  
38.          "      *        \n" );  
39.     // 绘制圆形  
40.     printf ( "\n" );  
41.     printf ( "          **          \n"  
42.          "    *            *    \n"  
43.          "  *                *  \n"  
44.          " *                  * \n"  
45.          "*                    *\n"  
46.          "*                    *\n"  
47.          "*                    *\n"  
48.          " *                  * \n"  
49.          "  *                *  \n"  
50.          "    *            *    \n"  
51.          "          **          \n" );  
52.   
53.     return 0;  
54. }  

     这种方法的缺点是：不灵活、不易修改。其优点是：直观、简单。

二、    使用控制结构

1、绘制矩形、三角形、菱形

    矩形：在知道需要输出的规格后，按行打印输出。比如需要打印5*5的矩形，可以直接使用嵌套的循环语句来控制行列数：

rows = 5;

for( i=0; i<rows; i++ )

{

    for( j=0; j<rows; j++ )

      printf( "*  " );

    printf( "\n" );

      }

    三角形和菱形：和矩形类似，只是每行*号的起始位置和个数不同

    下面是完整的代码：

1. /* 
2.  * 使用控制结构绘制图形 
3.  */  
4. #include <stdio.h>  
5.   
6. int main ( void )  
7. {  
8.     int rows, cols;  
9.     int i, j;  
10.   
11.     rows = 5;  
12.     cols = 8;  
13.   
14.     // 绘制正方形  
15.     printf ( "\n" );  
16.     for ( i=0; i<rows; i++ )  
17.     {  
18.         for ( j=0; j<rows; j++ )  
19.             printf ( "*  " );  
20.         printf ( "\n" );  
21.     }  
22.   
23.     // 绘制长方形  
24.     printf ( "\n" );  
25.     for ( i=0; i<rows; i++ )  
26.     {  
27.         for ( j=0; j<cols; j++ )  
28.             printf ( "*  " );  
29.         printf ( "\n" );  
30.     }  
31.   
32.     // 绘制三角形1  
33.     printf ( "\n" );  
34.     for ( i=0; i<rows; i++ )  
35.     {  
36.         for ( j=0; j<=i; j++ )  
37.             printf ( "*  " );  
38.         printf ( "\n" );  
39.     }  
40.     // 绘制三角形2  
41.     printf ( "\n" );  
42.     for ( i=0; i<rows; i++ )  
43.     {  
44.         for ( j=0; j<rows-i; j++ )  
45.             printf ( "*  " );  
46.         printf ( "\n" );  
47.     }  
48.     // 绘制三角形3  
49.     printf ( "\n" );  
50.     for ( i=0; i<rows; i++ )  
51.     {  
52.         for ( j=0; j<rows-i-1; j++ )  
53.             printf ( "   " );  
54.         for ( ; j<rows; j++ )  
55.             printf ( "*  " );  
56.         printf ( "\n" );  
57.     }  
58.     // 绘制三角形4  
59.     printf ( "\n" );  
60.     for ( i=0; i<rows; i++ )  
61.     {  
62.         for ( j=0; j<rows-i-1; j++ )  
63.             printf ( "   " );  
64.         for ( ; j<rows-i+2*i; j++ )  
65.             printf ( "*  " );  
66.         printf ( "\n" );  
67.     }  
68.       
69.     // 绘制菱形  
70.     printf ( "\n" );  
71.     for ( i=0; i<rows; i++ )  
72.     {  
73.         int blanks, stars;  
74.         blanks = i<rows/2 ? rows/2-i : i-rows/2;  
75.         stars = i<=rows/2 ? 2*i+1 : 2*(rows-i-1)+1;  
76.   
77.         for ( j=0; j<blanks; j++ )  
78.             printf ( "   " );  
79.         for ( j=0; j<stars; j++ )  
80.             printf ( "*  " );  
81.         printf ( "\n" );  
82.     }  
83.     return 0;  
84. }  

    得到的结果：

 

 

 

2、余弦函数0-2π图像

      a．首先观察我们需要输出的图像

 

考虑到只能逐行输出，除最下方的端点外，其他每行都需要输出两个点，我们使用*代替点。

      b．我们知道，输出的点越多，图像就会越接近真实情况，因此，不能让输出的行数太少，我们拟定输出行数为20行，由于此函数的值域是-1到1，所以步长应该为0.1。

      c．已经确定了行数，那么每一行的点该在哪儿出现呢？只需要计算出-1到1之间各点对应的acos值即可，也就是计算出函数图象上各已知纵坐标点的横坐标。

      d．观察反余弦函数

 

      发现，通过这个函数只能够得知0到π上各点的横坐标，并不能得到π到2π间（不在值域之内）各点的横坐标。再次观察余弦函数的图像，发现0到π区间的图线和π到2π之间的图线是轴对称的，对称轴是x=π，因此可以根据这个对称关系确定π到2π上各点的横坐标（2π-同一纵坐标值下的横坐标值）。

 

      e．输出各行：在每行的第一个点输出之前，需要先输出m（m为此点的横坐标）个空格，接着输出一个点，继续打印空格，直到打印的空格数为n（n为第二个点的横坐标），然后打印第二个点，最后输出换行符，结束这一行。依次按此方式输出各行 。

依据以上的分析，写出如下代码并运行：

 

1. /* 
2.  * 绘制cos函数在0~2pi之间图象 
3.  */  
4. #include <stdio.h>  
5. #include <math.h>  
6.   
7. #define PI 3.14  
8.   
9. int main ( void )  
10. {  
11.     int cols;  
12.     int c;  
13.     double r;  
14.   
15.     for ( r=1; r>=-1; r-=0.1 )  
16.     {  
17.         cols = acos ( r );  
18.   
19.         for ( c=0; c<cols; c++ )  
20.             printf ( " " );  
21.         printf ( "*" );  
22.   
23.         for ( ; c<2*PI-cols-1; c++ )  
24.             printf ( " " );  
25.         printf ( "*" );  
26.   
27.         printf ( "\n" );  
28.     }  
29.   
30.     return 0;  
31. }  

输出的图像如下： 

 

这个图像显然是不合要求的，图中的点并没有很好的分开，而是出现很多“重复”的行。导致这个现象的原因是，我们在找图线点的位置时，使用的函数acos只会产生0到π之间的一些值，而在输出空格时又是取这个函数结果的整数部分，也就是0到3，所以，有很多点的列号相同，就会出现不分散的情况。考虑到这个问题，我们将acos函数产生的值扩大10倍，这样就可以产生0到31这32个不同的列号，使点更加分散和接近真实情况，同样的，对称的部分点的列号也要相应地扩大10倍。

 

最终的代码如下：

 

1. /* 
2.  * 绘制cos函数在0~2pi之间图象 
3.  */  
4. #include <stdio.h>  
5. #include <math.h>  
6.   
7. #define PI 3.14  
8.   
9. int main ( void )  
10. {  
11.     int cols;  
12.     int c;  
13.     double r;  
14.   
15.     for ( r=1; r>=-1; r-=0.1 )  
16.     {  
17.         cols = acos ( r ) * 10;     // 列间距放大倍数为10  
18.   
19.         for ( c=0; c<cols; c++ )  
20.             printf ( " " );  
21.         printf ( "*" );  
22.   
23.         for ( ; c<2*PI*10-cols-1; c++ )  // 轴对称  
24.             printf ( " " );  
25.         printf ( "*" );  
26.   
27.         printf ( "\n" );  
28.     }  
29.   
30.     return 0;  
31. }  

  

得到的图像：

另外需要注意的是，在程序中要尽量精确控制空格的输出个数，这会在其他函数的绘制中有较大的影响。

 

3、正弦函数0-2π图像

    和余弦函数类似首先观察函数图像以及反函数的性质

    根据反正弦函数的性质，直接通过asin函数只能找到0到π/2之间的点，也可以找到-π/2到0之间的点，但是不能直接使用。我们需要的是0到2π之间的图像，0到π/2区间可以通过asin函数直接确定；π/2到π区间与0到π/2区间的图像关于x=π/2对称，可以确定；π到3π/2区间与-π/2到0区间的图像关于x=π/2对称，也能确定；最后，3π/2到2π区间图像可以由-π/2到0区间的图像向右平移2π得到。

    在确定了各区间上点的位置之后，接下来的做法就和余弦函数基本相同了，确定行数，扩大列号，打印输出，另外要注意上下两部分图形的拼接。

    最终完整的程序和结果如下：

1. /* 
2.  * 绘制sin函数在0~2pi之间图象 
3.  */  
4. #include <stdio.h>  
5. #include <math.h>  
6.   
7. #define PI 3.14  
8.   
9. int main ( void )  
10. {  
11.     double r;  
12.     int cols, c;  
13.   
14.     for ( r=1; r>0; r-=0.1 )  
15.     {  
16.         cols = asin ( r ) * 10;  
17.   
18.         for ( c=0; c<cols; c++ )  
19.             printf ( " " );  
20.         printf ( "*" );  
21.   
22.         for ( ; c<PI*10-cols-1; c++ )  
23.             printf ( " " );  
24.         printf ( "*" );  
25.   
26.         printf ( "\n" );  
27.     }  
28.   
29.     for ( r=0; r>=-1; r-=0.1 )  
30.     {  
31.         cols = ( PI - asin(r) ) * 10;  
32.   
33.         for ( c=0; c<cols+2; c++ )  
34.             printf ( " " );  
35.         printf ( "*" );  
36.   
37.         for ( ; c<10*(2*PI+asin(r))+1; c++ )  
38.             printf ( " " );  
39.         printf ( "*" );  
40.   
41.         printf ( "\n" );  
42.     }  
43.   
44.     return 0;  
45. }  

前面我们详细介绍了C语言绘制常见图形和正弦余弦图像的方法，此篇文章为上一篇（http://blog.csdn.net/duanxu_yzc/article/details/12745757，强烈建议：先看上一篇再看续集！！！）的继续，主要有以下内容：

      圆形和抛物线的绘制

      绘制函数图像的第二种方法

      同一坐标系下绘制多个函数图像（交叉图像）

4、圆形和抛物线的绘制

   有了前面绘制三角函数图像的基础，圆形和抛物线的绘制应该非常简单，我们以圆形为例说明：

a、观察需要绘制的图像

      每行需要输出两个点，而且图像左右轴对称

   b、使用的函数：（x-10）²+（y-10）²=10²

   c、输出21行，行坐标间距为1

   d、左半圆的列号：10-sqrt(100-(r-10)*(r-10))

      右半圆的列号：10+sqrt(100-(r-10)*(r-10))

   e、调整输出行宽比（因屏幕的行宽比不是一比一，因此不进行调整会导致输出为椭圆）

   按照以上步骤编写代码如下：

  

 C++ Code By DuanXu-yzc

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

/*
 * 绘制圆形（圆心坐标（10，10），半径为10）
 */
#include <stdio.h>
#include <math.h>

int main ( void )
{
    int rows;
    int r;
    int c;
    float adjust;

    rows = 20;
    adjust = 2.3;   // 屏幕行宽比（输出屏幕行间距和列间距不同，用adjust作为调整）

    for ( r=20; r>=0; r-- )
    {
        // 左半圆
        for ( c=0; c<adjust*(10-sqrt(100-(r-10)*(r-10))); c++ )
            printf ( " " );
        printf ( "*" );

        // 右半圆
        for ( ; c<adjust*(10+sqrt(100-(r-10)*(r-10))); c++ )
            printf ( " " );
        printf ( "*" );

        printf ( "\n" );
    }

    return 0;
}

得到的图像：

抛物线的绘制与圆形极为相似，直接上代码和结果：

1. /* 
2.  * 绘制抛物线 
3.  */  
4. #include <stdio.h>  
5. #include <math.h>  
6.   
7. int main ( void )  
8. {  
9.     int rows;  
10.     int r;  
11.     int c;  
12.     double adjust = 2.3;  
13.   
14.     rows = 20;  
15.   
16.     for ( r=rows; r>=0; r-- )  
17.     {  
18.         for ( c=0; c<adjust*(10-sqrt(5*r)); c++ )  
19.             printf ( " " );  
20.         printf ( "*" );  
21.   
22.         for ( ; c<adjust*(10+sqrt(5*r)); c++ )  
23.             printf ( " " );  
24.         printf ( "*" );  
25.   
26.         printf ( "\n" );  
27.     }  
28.   
29.     return 0;  
30. }  

5、绘制函数图像的第二种方法

    到目前为止，我们使用的方法都是逐行输出，然后通过反函数找到每行需要输出星号的位置，最后通过输出相应个数的空格，确定星号的位置，输出星号。现在介绍另外一种方法，其实与已知的方法很相似，区别在于不需要先输出空格来确定星号的位置，而是逐个判断每行中的各列需要输出的字符是空格还是星号，以圆形为例，每行中，只有列号（调整比例后的）为adjust*(10-sqrt(5*r)和adjust*(10+sqrt(5*r)的位置需要输出星号，其余位置均输出空格。按照这个方法我们重新编写程序如下：

1. /* 
2.  * 绘制圆形（圆心坐标（10，10），半径为10）的另一种方法 
3.  */  
4.   
5. #include <stdio.h>  
6. #include <math.h>  
7.   
8. int main ( void )  
9. {  
10.     int rows;  
11.     int r;  
12.     int c;  
13.     int left;  
14.     int right;  
15.     float adjust = 2.3;  
16.   
17.     rows = 20;  
18.     for ( r=rows; r>=0; r-- )  
19.     {  
20.         left = adjust*(10-sqrt(100-(r-10)*(r-10))); // 左半圆的列号（将浮点转化为整型）  
21.         right = adjust*(10+sqrt(100-(r-10)*(r-10)));    // 右半圆的列号（将浮点转化为整型）  
22.   
23.         for ( c=0; c<=adjust*20; c++ )  
24.         {  
25.             if ( c == left || c == right )  
26.                 printf ( "*" );  
27.             else  
28.                 printf ( " " );  
29.         }  
30.         printf ( "\n" );  
31.     }  
32.   
33.     return 0;  
34. }  

得到图像：

（这个图像与前一种方法绘制的图像有一处明显不同，为什么？请读者思考。）

 

   6、同一坐标系下绘制多个函数图像（交叉图像）

   我们来观察一下直线和圆在同一坐标系下相交的图形：

    同样，这个图像也需要逐行输出，如果按照第一种绘制方法，就需要确定每行中星号的位置，我们发现，图像上半部分的星号依次出现在：左半圆、右半圆、直线，中间部分是：左半圆、直线、右半圆，下半部分是：直线、左半圆、右半圆，这使得我们需要在程序中需要针对不同的行段采取不同的输出顺序，如果图像更复杂的话，这同情况会变得更糟糕。我们再看看第二种绘制方法，这种方法只需要知道哪些地方需要输出星号，并不需要明确的顺序，因此更适合这种交叉图像输出的情况，下面是绘制直线和圆的代码和结果：

1. /* 
2.  * 同一坐标系下绘制圆形和直线 
3.  */  
4. #include <stdio.h>  
5. #include <math.h>  
6.   
7. int main ( void )  
8. {  
9.     int rows = 20;  
10.     int r;  
11.     int c;  
12.     int round_l;  
13.     int round_r;  
14.     int line;  
15.   
16.     float adjust = 2.3;  
17.   
18.     for ( r=rows; r>=0; r-- )  
19.     {  
20.         round_l = adjust*(10-sqrt(100-(r-10)*(r-10)));  
21.         round_r = adjust*(10+sqrt(100-(r-10)*(r-10)));  
22.         line = adjust*r;  
23.   
24.         for ( c=0; c<=adjust*20; c++ )  
25.             if ( ( c == round_l  &&  c == line ) ||  
26.                  ( c == round_r  &&  c == line ) )  
27.                 printf ( "+" );         // 交叉的点标记'+'  
28.   
29.             else if ( c == round_l  ||  c == round_r )  
30.                 printf ( "*" );         // 圆形边界标记'*'  
31.   
32.             else if ( c == line )  
33.                 printf ( "+" );         // 直线标记'+'  
34.   
35.             else  
36.                 printf ( " " );         // 其它位置标记空格  
37.   
38.         printf ( "\n" );  
39.     }  
40.   
41.     return 0;  
42. }  

    使用同样的方法绘制余弦和正弦的交叉图像如下：

1. /* 
2.  * 同一坐标系中绘制余弦和正弦图像 
3.  */  
4. #include <stdio.h>  
5. #include <math.h>  
6.   
7. #define PI 3.14  
8.   
9. int main ( void )  
10. {  
11.     int rows = 20;  
12.     float r;  
13.     int c;  
14.     int sin_1;  
15.     int sin_2;  
16.     int sin_3;  
17.     int sin_4;  
18.     int cos_1;  
19.     int cos_2;  
20.   
21.     float adjust = 10;  
22.   
23.     for ( r=1; r>0; r-=0.1 )  
24.     {  
25.         sin_1 = adjust * asin(r);  
26.         sin_2 = adjust * (PI-asin(r));  
27.         cos_1 = adjust * acos(r);  
28.         cos_2 = adjust * (2*PI-acos(r));  
29.   
30.         for ( c=0; c<=adjust*2*PI; c++ )  
31.             if ( ( c == sin_1  &&  c == cos_1 )  ||  
32.                  ( c == sin_2  &&  c == cos_1 )  ||  
33.                  ( c == sin_1  &&  c == cos_2 )  ||  
34.                  ( c == sin_2  &&  c == cos_2 ) )  
35.                 printf ( "+" );  
36.   
37.             else if ( c == sin_1  || c == sin_2 )  
38.                 printf ( "*" );  
39.   
40.             else if ( c == cos_1  ||  c == cos_2 )  
41.                 printf ( "+" );  
42.   
43.             else  
44.                 printf ( " " );  
45.   
46.         printf ( "\n" );  
47.     }  
48.   
49.     for ( r=0; r>=-1; r-=0.1 )  
50.     {  
51.         sin_3 = adjust * (PI-asin(r));  
52.         sin_4 = adjust * (2*PI+asin(r));  
53.         cos_1 = adjust * acos(r);  
54.         cos_2 = adjust * (2*PI-acos(r));  
55.   
56.         for ( c=0; c<=adjust*2*PI; c++ )  
57.             if ( ( c == sin_3  &&  c == cos_1 )  ||  
58.                  ( c == sin_4  &&  c == cos_1 )  ||  
59.                  ( c == sin_3  &&  c == cos_2 )  ||  
60.                  ( c == sin_4  &&  c == cos_2 ) )  
61.                 printf ( "+" );  
62.   
63.             else if ( c == sin_3  || c == sin_4 )  
64.                 printf ( "*" );  
65.   
66.             else if ( c == cos_1  ||  c == cos_2 )  
67.                 printf ( "+" );  
68.   
69.             else  
70.                 printf ( " " );  
71.   
72.         printf ( "\n" );  
73.     }  
74.   
75.     return 0;  
76. }  

 

本章总结

        图形输出是C语言初学者经常遇到的问题，实际上大多数简单的图形并不需要使用复杂的控制结构，所见即所得的方法更加简洁，不过对于复杂的图形或者函数图像，使用控制结构会更好。在使用控制结构输出图形时，要把握一个原则：只能逐行输出，因此，在输出一行时必须把这一行中所有需要输出的字符全部输出，所以，找到每行中各个位置需要输出的字符（或者说，各字符在每行中的位置）尤为关键！我们有两种方法来确定位置，其中第二种方法更通用简洁。在输出图形时，特别是函数图像，要充分利用对称、平移关系简化程序，另外，要注意调节屏幕的行宽比和适当的图像放大，防止图像失真。