2014年3月9日星期日（DEMO8-6,画家算法）

最新推荐文章于 2022-09-26 21:37:33 发布
最新推荐文章于 2022-09-26 21:37:33 发布
阅读量820 收藏 1
点赞数
分类专栏： 业余封装3D软引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/directx3d_beginner/article/details/36159117
版权

概括说，就是先绘制离视点远的物体，再绘制离视点近的物体，这样离视点较近的物体将自动覆盖背景。

可以根据渲染列表中的每个多边形的Z值，从后到前的顺序排列

对于多边形较小，且不是凹的，不互相重叠，是可行的。

排序是根据相机坐标进行，所以要在世界坐标系到相机坐标变换之后和相机坐标到透视坐标之前进行。

 

定义几个常量用来排序渲染列表中的多边形

 

#define SORT_POLYLIST_AVGZ                  0

#define SORT_POLYLIST_NEARZ                     1

#define                           SORT_POLYLIST_FARZ                  2

比较函数随之分三个，比较NEARZ,AVGZ和FARZ，用来当判断标准。

 

int ddraw_liushuixian::Compare_AvgZ_PolyF4DV1( const void * arg1, const void * arg2 )

{

    float                 z1, z2;

    POLYF4DV1_PTR         poly_1, poly_2;

 

    poly_1                                      = * ( ( POLYF4DV1_PTR * ) ( arg1 ));

    poly_2                                      = * ( ( POLYF4DV1_PTR * ) ( arg2 ));

 

    z1                                          = ( float ) 0.33333 * ( poly_1->tvlist[0].z + poly_1->tvlist[1].z + poly_1->tvlist[2].z );

    z2                                          = ( float ) 0.33333 * ( poly_2->tvlist[0].z + poly_2->tvlist[1].z + poly_2->tvlist[2].z );

 

    if ( z1 > z2 )

    {

         return -1;

    }

    else

    if ( z1 < z2)

    {

         return 1;

    }

    else

    {

         return 0;

    }

 

   

}

 

int ddraw_liushuixian::Compare_NearZ_PolyF4DV1( const void * arg1, const void * arg2 )

{

    float                 z1, z2;

    POLYF4DV1_PTR         poly_1, poly_2;

 

    poly_1                                      = * ( ( POLYF4DV1_PTR * ) ( arg1 ));

    poly_2                                      = * ( ( POLYF4DV1_PTR * ) ( arg2 ));

 

    z1                                          = MIN( poly_1->tvlist[0].z, poly_1->tvlist[1].z );

    z1                                          = MIN( z1, poly_1->tvlist[2].z );

    z2                                          = MIN( poly_2->tvlist[0].z, poly_2->tvlist[1].z );

    z2                                          = MIN( z2, poly_2->tvlist[2].z );

 

    if ( z1 > z2 )

    {

        return -1;

    }

    else

         if ( z1 < z2)

         {

             return 1;

         }

         else

         {

             return 0;

         }

 

 

}

 

int ddraw_liushuixian::Compare_FarZ_PolyF4DV1( const void * arg1, const void * arg2 )

{

    float                 z1, z2;

    POLYF4DV1_PTR         poly_1, poly_2;

 

    poly_1                                      = * ( ( POLYF4DV1_PTR * ) ( arg1 ));

    poly_2                                      = * ( ( POLYF4DV1_PTR * ) ( arg2 ));

 

    z1                                          = MAX( poly_1->tvlist[0].z, poly_1->tvlist[1].z );

    z1                                          = MAX( z1, poly_1->tvlist[2].z );

    z2                                          = MAX( poly_2->tvlist[0].z, poly_2->tvlist[1].z );

    z2                                          = MAX( z2, poly_2->tvlist[2].z );

 

    if ( z1 > z2 )

    {

         return -1;

    }

    else

         if ( z1 < z2)

         {

             return 1;

         }

         else

         {

             return 0;

         }

 

 

}

 

按照各种情况进行排序

int ddraw_liushuixian::Sort_RENDERLIST4DV1( RENDERLIST4DV1_PTR rend_list, int sort_method )

{

    switch( sort_method )

    {

    case SORT_POLYLIST_AVGZ:

         {

            qsort( ( void *) rend_list->poly_ptrs, rend_list->num_polys, sizeof( POLYF4DV1_PTR ), Compare_AvgZ_PolyF4DV1 );

         }

         break;

    case SORT_POLYLIST_NEARZ:

         {

            qsort( ( void *) rend_list->poly_ptrs, rend_list->num_polys, sizeof( POLYF4DV1_PTR ), Compare_NearZ_PolyF4DV1);

         }

         break;

    case SORT_POLYLIST_FARZ:

         {

            qsort( ( void *) rend_list->poly_ptrs, rend_list->num_polys, sizeof( POLYF4DV1_PTR ), Compare_FarZ_PolyF4DV1 );

         }

         break;

 

    default:

         break;

    }

}

 

下面，进行主程序看看，

在GAME_MAIN()的每帧中，设定一个Z排序模式，

static int zsort_mode     = 1;

 

    liushuixian.Insert_OBJECT4DV1_RENDERLIST4DV12( * math, & render_list, & obj_player, 0, 0 );

                  liushuixian.Insert_OBJECT4DV1_RENDERLIST4DV12( * math, & render_list, & obj_tank, 0, 0 );

             liushuixian.Insert_OBJECT4DV1_RENDERLIST4DV12( * math, & render_list, & obj_tower,0,0 );

 

 

光照是在渲染列表中进行，

 

int ddraw_liushuixian::Light_RENDERLIST4DV1_World16( ddraw_math math, int rgb_format, RENDERLIST4DV1_PTR rend_list, CAM4DV1_PTR cam, LIGHTV1_PTR lights, int max_lights )

{

    unsigned     int               r_base, g_base, b_base,            //原来的颜色值

                                       r_sum, g_sum, b_sum,           //全部光源的总体光照效果

                                       shaded_color;                      //最后的颜色

    float                              dp,                                //点积

                                       dist,                              //表面和光源之间的距离

                                        i,                                 //强度

                                       nl,                                //法线长度

                                       atten;                             //衰减计算结果

 

    for ( int poly = 0; poly < rend_list->num_polys; poly ++)

    {

         POLYF4DV1_PTR                  curr_poly             = rend_list->poly_ptrs[poly];

 

   

         if ( ! ( curr_poly->state & OBJECT4DV1_STATE_ACTIVE ) ||

             ( curr_poly-> state & OBJECT4DV1_STATE_CULLED ) ||

             ! ( curr_poly->state & OBJECT4DV1_STATE_VISIBLE))

             {

                  return ( 0 );

             }

        

         //检查多边形的着色模式

         if ( curr_poly->attr & POLY4DV1_ATTR_SHADE_MODE_FLAT ||

             curr_poly->attr & POLY4DV1_ATTR_SHADE_MODE_GOURAUD )

         {

             //提取多边形颜色的RGB值

             if ( rgb_format == DD_PIXEL_FORMAT565 )

             {

                  _RGB565FROM16BIT( curr_poly->color, & r_base, & g_base, & b_base );

                  //转换成.8.8格式

                  r_base                                 <<= 3;

                  g_base                                 <<= 2;

                  b_base                                 <<= 3;

             }

             else

             {

                  _RGB555FROM16BIT( curr_poly->color, & r_base, & g_base, & b_base );

                  //转换成.8.8格式

                  r_base                                 <<= 3;

                  g_base                                 <<= 3;

                  b_base                                 <<= 3;

             }

 

             //初始化总体光照颜色

             r_sum                                       = 0;

             g_sum                                       = 0;

             b_sum                                       = 0;

 

             //遍历光照

             for ( int curr_light = 0; curr_light < max_lights; curr_light ++)

             {

                  //光源是否被打开

                  if ( lights[curr_light].state== LIGHTV1_STATE_OFF)

                  {

                      continue;

                  }

 

                  //判断光源类型

                  if ( lights[curr_light].attr & LIGHTV1_ATTR_AMBIENT )

                  {

                      r_sum                              += ( ( lights[curr_light].c_ambient.r * r_base) / 256 );

                      g_sum                              += ( ( lights[curr_light].c_ambient.g * g_base) / 256 );

                      b_sum                              += ( ( lights[curr_light].c_ambient.b * b_base) / 256 );

 

                  }

                  else

                      if ( lights[curr_light].attr & LIGHTV1_ATTR_INFINITE )

                      {

                          VECTOR4D u, v, n;

                          math.VECTOR4D_Build( & curr_poly->tvlist[0], & curr_poly->tvlist[1], & u );

                          math.VECTOR4D_Build( & curr_poly->tvlist[0], & curr_poly->tvlist[1], & v );

                          math.VECTOR4D_CROSS( & u, &v, &n );

 

                          nl                                 = math.VECTOR4D_length(&n);

 

                          dp                                 = math.VECTOR4D_DOT( &n, & lights[curr_light].dir );

 

                          if ( dp > 0 )

                          {

                               i                              = 128 * dp / nl;

                               r_sum                          += (  lights[curr_light].c_diffuse.r * r_base * i ) / ( 256 * 128);

                               g_sum                          += (  lights[curr_light].c_diffuse.g * g_base * i ) / ( 256 * 128);

                               b_sum                          += (  lights[curr_light].c_diffuse.b * b_base * i ) / ( 256 * 128);

 

                          }

 

 

                      }

                      else

                          if ( lights[curr_light].attr & LIGHTV1_ATTR_POINT )

                          {

                               VECTOR4D u, v, n, l;

                               math.VECTOR4D_Build( & curr_poly->tvlist[0], & curr_poly->tvlist[1], & u );

                               math.VECTOR4D_Build( & curr_poly->tvlist[0], & curr_poly->tvlist[1], & v );

                               math.VECTOR4D_CROSS( & u, &v, &n );

 

                               nl                                 = math.VECTOR4D_length(&n);

 

                               //计算从表面到光源的向量

                               math.VECTOR4D_Build( &curr_poly->tvlist[0], & lights[curr_light].pos, &l );

                               //计算距离和衰减

                               dist                           = math.VECTOR4D_length( &l);

 

 

                               dp                                 = math.VECTOR4D_DOT( &n, & l);

 

                               if ( dp > 0 )

                               {

                                   atten                          = ( lights[curr_light].kc + lights[curr_light].kl * dist + lights[curr_light].kq * dist * dist );

                                   i                              = 128 * dp / ( nl * dist * atten );

                                   r_sum                          += (  lights[curr_light].c_diffuse.r * r_base * i ) / ( 256 * 128);

                                   g_sum                          += (  lights[curr_light].c_diffuse.g * g_base * i ) / ( 256 * 128);

                                   b_sum                          += (  lights[curr_light].c_diffuse.b * b_base * i ) / ( 256 * 128);

 

                               }

 

 

                          }

                          else

                               if ( lights[curr_light].attr & LIGHTV1_ATTR_SPOTLIGHT1 )

                              {

                                   VECTOR4D u, v, n, l;

                                   math.VECTOR4D_Build( & curr_poly->tvlist[0], & curr_poly->tvlist[1], & u );

                                   math.VECTOR4D_Build( & curr_poly->tvlist[0], & curr_poly->tvlist[1], & v );

                                   math.VECTOR4D_CROSS( & u, &v, &n );

                                   nl                                 = math.VECTOR4D_length(&n);

 

                                   //计算从表面到光源的向量

                                   math.VECTOR4D_Build( &curr_poly->tvlist[0], & lights[curr_light].pos, &l );

                                   //计算距离和衰减

                                   dist                           = math.VECTOR4D_length( &l);

 

 

                                   dp                                 = math.VECTOR4D_DOT( &n, & lights[curr_light].dir );

 

                                   if ( dp > 0 )

                                   {

                                       atten                          = ( lights[curr_light].kc + lights[curr_light].kl * dist + lights[curr_light].kq * dist * dist );

                                       i                              = 128 * dp / ( nl * atten );

                                       r_sum                          += (  lights[curr_light].c_diffuse.r * r_base * i ) / ( 256 * 128);

                                       g_sum                          += (  lights[curr_light].c_diffuse.g * g_base * i ) / ( 256 * 128);

                                       b_sum                          += (  lights[curr_light].c_diffuse.b * b_base * i ) / ( 256 * 128);

 

                                   }

 

 

                               }  

                               else

                                   if ( lights[curr_light].attr & LIGHTV1_ATTR_SPOTLIGHT2 )

                                   {

                                       VECTOR4D u, v, n, d, s;

                                       math.VECTOR4D_Build( & curr_poly->tvlist[0], & curr_poly->tvlist[1], & u );

                                       math.VECTOR4D_Build( & curr_poly->tvlist[0], & curr_poly->tvlist[1], & v );

                                       math.VECTOR4D_CROSS( & u, &v, &n );

 

                                       nl                                 = math.VECTOR4D_length(&n);

                                       dp                                 = math.VECTOR4D_DOT( &n, & lights[curr_light].dir );

 

                                       if ( dp > 0 )

                                       {

                                            //计算从表面到光源的向量

                                            math.VECTOR4D_Build( & lights[curr_light].pos, &  curr_poly->tvlist[0],  &s );

                                            dist                      = math.VECTOR4D_length( &s);

 

                                            float    dpsl              = math.VECTOR4D_DOT( & s, & lights[curr_light].dir ) / dist;

 

                                            if ( dpsl > 0)

                                            {

                                                atten                     = ( lights[curr_light].kc + lights[curr_light].kl * dist + lights[curr_light].kq * dist * dist );

                                                float    dpsl_exp     = dpsl;

                                                for ( int e_index = 1; e_index < ( int ) lights[curr_light].pf; e_index++ )

                                                {

                                                     dpsl              *= dpsl;

                                                }

                                                i                         = 128 * dp * dpsl_exp / ( nl * atten );

                                                r_sum                     += (  lights[curr_light].c_diffuse.r * r_base * i ) / ( 256 * 128);

                                                g_sum                     += (  lights[curr_light].c_diffuse.g * g_base * i ) / ( 256 * 128);

                                                b_sum                      += (  lights[curr_light].c_diffuse.b * b_base * i ) / ( 256 * 128);

                                            }

 

 

                                       }

 

 

                                   }  

             }

             //确保颜色分量不溢出

             if ( r_sum   > 255 )

             {

                  r_sum                                                = 255;

 

             }

             if ( g_sum   > 255 )

             {

                  g_sum                                                = 255;

 

             }

             if ( b_sum   > 255 )

             {

                  b_sum                                                = 255;

 

             }

 

             //写入颜色

             if ( rgb_format == DD_PIXEL_FORMAT565 )

             {

 

                  shaded_color                                    = _RGB16BIT565( r_sum, g_sum, b_sum );

             }

             else

                  if ( rgb_format == DD_PIXEL_FORMAT555 )

                  {

                      shaded_color                                    = _RGB16BIT555( r_sum, g_sum, b_sum );

                  }

                  curr_poly->color                                     = ( int ) ( ( shaded_color << 16 ) | curr_poly->color );

         }

         else

         {

    //       curr_poly->color                                     = ( int ) ( ( curr_poly->color << 16 ) | curr_poly->color );

 

         }

 

    }

}

 

在GAME_Main()中光照处理列表

    liushuixian.Light_RENDERLIST4DV1_World16( *math, DD_PIXEL_FORMAT565, &render_list, & cam, lightGroup, 4 );

然后进行Z排序，OK了。

 

directx3d_beginner
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Day 3
weixin_43144998的博客
03-10 349
1.画家算法和Z-BUFFER渲染 ①：画家算法是：将场景中的物体进行远近排序，按照由远到近的顺序进行绘制，将不可见的部分覆盖。 缺点：每个物体都完整的绘制，没有考虑到最终是不会显示到屏幕上的像素，过多的浪费资源。 无法实现相互重叠的效果 ②：Z-BUFFER算法是： 定义一个帧缓冲数组FBO（x,y）存放这个像素的颜色。 定义一个深度缓冲 DBO (x,y）存放这个像素的深度。 z轴扫描线穿透xoy平面，与多边体相交于若干的点，比较相交点的Z值，z值越大距离观察点越近，将z值最大的点的颜色和深度分别写入F
14.曲面消隐——图像空间算法（Z-buffer）+对象空间算法（画家算法+二叉空间剖分树）
Valieli的博客
12-10 6684
♥,.*,.♥,.*,.♥,.*,.♥,.*♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥♥,.*,.♥,.*,.♥,.*,.♥,.*♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥,.*,.♥ 目录 1.曲面消隐 2.曲面消隐算法——图像空间算法 3.曲面消隐算法——对象空间算法 ♥,.*,.♥,.*,.♥,.*,.♥,...
4、计算机图形学——光栅化、抗锯齿、画家算法和深度缓冲算法（Z-buffer）
Master Cui的博客
07-29 4169
一、光栅化（Rasterization） 1.1、概念 光栅raster这个词就是德语中屏幕的意思，光栅化的意思就是将图像绘制在屏幕上进行显示。 1.2、三角形光栅化过程简述 首先，为什么要以三角形的光栅化为例呢，因为三角形是最基本的多边形，大部分的模型都是用一个个三角形表示，任意的其它多边形其实都可以转化成多个三角形的形式，因此以三角形的光栅化为例 如下图所示，给定了三个点，如何将得到的三角形绘制在右边的屏幕上？ 首先需要进行采样，采样的意思就是对给定的函数进行离散化，比如上图中，要实
计算机图形学（十一）：真实感图形（画家算法消除隐藏面）
乔卿的博客
09-26 2559
先将画面中的物体按其距离观察点的远近进行排序，结果存放在一张线形表中。距观察点远者称其优先级高，放在表头,距观察点近者称其优先级低，放在表尾，这张表称为深度优先级表。
games101学习笔记_shading1(着色)
weixin_43789369的博客
10-12 553
可视性 / 遮挡(Visibility / occlusion) 画家算法(Painter 's Algorithm) 画家算法的提出主要是为了实现深度缓冲. 画家在画油画时，总是会从远景开始画，然后逐渐画近景覆盖远景，比如下图：最先画出一个蓝色的山，然后接着画绿地覆盖蓝色的闪，然后再接着画上几棵树覆盖绿地。 比如我们想要画一个正方体： 先画出最后面的面，然后再画上面和右面，最后画正面。就可以得到这样一个正方体。先画背面最后画正面可以理解，那么四个侧面的顺序是如何决定的？目前我们只是暂时用这种画法，没有什
计算机图形学笔记五：光栅化（消隐算法）和 前几节内容总结
qq_51776686的博客
01-13 757
计算机图形学自学笔记之消隐算法和总结
webrtc-demo(3月5日最新版).zip
03-09
采用的代码是 /4435 2021-03-05-4435的版本， vs是2019里面包含了windows arm64 linux下平台的库。包含了在vs下如何使用webrtc的vs工程 你就不用在去下载webrtc和进行编译源码了 如果需要源码可以联系我 ，我发给你...
C语言03-用P6，P7口驱动8个数码管（STC32G-DEMO-CODE-220311kw）
06-14
C语言03-用P6，P7口驱动8个数码管（STC32G-DEMO-CODE-220311kw）C语言03-用P6，P7口驱动8个数码管（STC32G-DEMO-CODE-220311kw）C语言03-用P6，P7口驱动8个数码管（STC32G-DEMO-CODE-220311kw）C语言03-用P6，P7口...
STM32F103C8T6例程-DEMO.zip
09-03
STM32F103C8T6例程-DEMOSTM32F103C8T6例程-DEMOSTM32F103C8T6例程-DEMOSTM32F103C8T6例程-DEMOSTM32F103C8T6例程-DEMOSTM32F103C8T6例程-DEMOSTM32F103C8T6例程-DEMOSTM32F103C8T6例程-DEMOSTM32F103C8T6例程-DEMO
antV-X6-demo-master.zip
04-16
4. **布局算法**：内置了多种布局算法，如树形布局、力引导布局等，适用于不同复杂度的数据结构展示。 5. **动画效果**：通过丰富的动画API，可以实现平滑的过渡和动态效果，增强用户体验。 6. **Vue集成**：这个...
2018年1月9日新版支付宝nodejs+Express Demo
01-09
在本文中，我们将深入探讨如何使用Node.js和Express框架构建2018年1月9日新版支付宝的示例应用。这个Demo项目是基于当时支付宝的API接口，旨在帮助开发者理解如何集成支付宝支付功能到自己的Web应用中。下面将详细...
OpenGL使用画家算法实现隐藏面的消除的旋转正方体
12-23
OpenGL使用画家算法实现隐藏面的消除的旋转正方体
计算机图形学中的着色
牵LV小猪精的博客
02-17 843
计算机图形学中的着色1.画家算法深度缓冲（Z - Buffer）Z-Buffer实例深度缓冲的算法（Z - Buffer Algorithm） 1.画家算法 画家在画油画时，会从远景开始画起，然后逐渐画近景覆盖远景，比如下图： 参考画家算法，在屏幕空间中画一个正方体就需要如下的绘制步骤： 首先绘制最远的那个面（后面），然后再画左面和下面，之后再画上面和右面，最后画正面。就可以得到这样一个正方体。先画背面最后画正面可以理解，那么四个侧面的顺序是如何决定的？目前我们只是暂时用这种画法，没有什么特殊的决定方法
GAMES101第七讲Shading 1笔记
qq_41421484的博客
02-13 189
GAMES101第七讲Shading 1笔记
现代计算机图形学入门（四）———— 着色
Fyantu的博客
08-07 996
文章目录1 可见性（Visibility）1.1 画家算法1.2 Z-Buffer算法2 着色（Shading）2.1 Blinn-Phong反射模型2.1.1 漫反射 1 可见性（Visibility） 1.1 画家算法 对于一幅图，我们一般是先把远景画完，然后再用近景将部分远景覆盖，最终得到一幅画，在图形学中这样的一种算法过程被称为画家算法 在图形学中我们想画一个立方体，画画的顺序也挺讲究，如下正方体，如果我们不是以左上右下的顺序画，左面就会有一条棱线显现出来。 在一般的情况下，
计算机图形学-油画家算法
Fitz的博客
12-29 7856
利用油画家算法实现隐藏面的消除。设有四个平面,在屏幕上显示这四个平面,使前面的平面覆盖后面的平面。 #include #include #include #include #include #include using namespace std; int a[4],b[4],i; void initial() { cout<<"请分别输入圆形，三角形，椭圆形，矩形的Z值："; fo
立方体画家消隐算法与Z-Buffer消隐算法 比较
热门推荐
把握自己。
12-01 1万+
画家算法，又称深度排序法。 我们先看看它的算法： （1）将屏幕设成背景色， （2）把要画的物体（多边形）按其离开视点的从远到近排序(#add 确定可以排序么?不会有交叉的面?这个距离又是指哪个点到哪个点? 从后文得知,画家算法不适用于交叉的情况,只能针对包围体,此距离也是个最小距离)。由此构成深度优先级表。然后从远到近画物体（多边形），近的就因为优先级高而覆盖远的多边形。由此可消隐。
立方体画家消隐算法与Z-Buffer消隐算法比较
cbbbc
04-11 4631
画家算法，又称深度排序法。 我们先看看它的算法： （1）将屏幕设成背景色， （2）把要画的物体（多边形）按其离开视点的从远到近排序(#add 确定可以排序么?不会有交叉的面?这个距离又是指哪个点到哪个点? 从后文得知,画家算法不适用于交叉的情况,只能针对包围体,此距离也是个最小距离)。由此构成深度优先级表。然后从远到近画物体（多边形），近的就因为优先级高而覆盖远的多边形。由此可消隐。
枚举-画家问题（算法基础 第2周）
NodYoung
06-04 2583
问题描述： 分析: 不好意思了，课程的题目不注册没法看，只能贴图。 原题是POJ上的：http://cxsjsxmooc.openjudge.cn/test/Y/ 有一小点改动，即课程要求可以输入多个案例。 这道题跟熄灯问题很像啦。 源码:#include <iostream> using namespace std;int wall[16][17]={0},press[16]
使用fork()创建子进程，形成以下父子关系 期望父子进程树 demo3---demo3---demo3---demo3---demo3---demo3---demo3---demo3---demo3---demo3 注：demo3为程序名
最新发布
04-10
使用fork()函数可以创建一个子进程，形成父子关系。在这个例子中，我们可以使用循环来创建多个子进程，形成父子进程树。 以下是一个示例代码： ```c #include <stdio.h> #include <unistd.h> int main() { int i; for (i = 0; i < 10; i++) { if (fork() == 0) { printf("demo3---"); } else { wait(NULL); break; } } return 0; } ``` 在这个示例中，我们使用了一个循环来创建10个子进程。每个子进程都会打印出"demo3---"，而父进程则会等待子进程结束后退出。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值