c语言滑窗法_窗函数的C语言实现

1 /*

2 *file WindowFunction.c3 *author Vincent Cui4 *e-mail whcui1987@163.com5 *version 0.36 *data 31-Oct-20147 *brief 各种窗函数的C语言实现8 */

11 #include "WindowFunction.h"

12 #include "GeneralConfig.h"

13 #include "MathReplenish.h"

14 #include "math.h"

15 #include

16 #include

17 #include

19 /*函数名：taylorWin20 *说明：计算泰勒窗。泰勒加权函数21 *输入：22 *输出：23 *返回：24 *调用：prod()连乘函数25 *其它：用过以后，需要手动释放掉*w的内存空间26 * 调用示例：ret = taylorWin(99, 4, 40, &w); 注意此处的40是正数表示-40dB27 */

28 dspErrorStatus taylorWin(dspUint_16 N, dspUint_16 nbar, dspDouble sll, dspDouble **w)29 {30 dspDouble A;31 dspDouble *retDspDouble;32 dspDouble *sf;33 dspDouble *result;34 dspDouble alpha,beta,theta;35 dspUint_16 i,j;36

37 /*A = R cosh(PI, A) = R*/

38 A = (dspDouble)acosh(pow((dspDouble)10.0,(dspDouble)sll/20.0)) /PI;39 A = A *A;40

41 /*开出存放系数的空间*/

42 retDspDouble = (dspDouble *)malloc(sizeof(dspDouble) * (nbar - 1));43 if(retDspDouble ==NULL)44 returnDSP_ERROR;45 sf =retDspDouble;46

47 /*开出存放系数的空间*/

48 retDspDouble = (dspDouble *)malloc(sizeof(dspDouble) *N);49 if(retDspDouble ==NULL)50 returnDSP_ERROR;51 result =retDspDouble;52

53 alpha = prod(1, 1, (nbar - 1));54 alpha *=alpha;55 beta = (dspDouble)nbar / sqrt( A + pow((nbar - 0.5), 2) );56 for(i = 1; i <= (nbar - 1); i++)57 {58 *(sf + i - 1) = prod(1,1,(nbar -1 + i)) * prod(1,1,(nbar -1 -i));59 theta = 1;60 for(j = 1; j <= (nbar - 1); j++)61 {62 theta *= 1 - (dspDouble)(i * i) / ( beta * beta * ( A + (j - 0.5) * (j - 0.5)) );63 }64 *(sf + i - 1) = alpha * (dspDouble)theta / (*(sf + i - 1));65 }66

67 /*奇数阶*/

68 if((N % 2) == 1)69 {70 for(i = 0; i < N; i++)71 {72 alpha = 0;73 for(j = 1; j <= (nbar - 1); j++)74 {75 alpha += (*(sf + j - 1)) * cos( 2 * PI * j * (dspDouble)(i - ((N-1)/2))/N );76 }77 *(result + i) = 1 + 2 *alpha;78 }79 }80 /*偶数阶*/

81 else

82 {83 for(i = 0; i < N; i++)84 {85 alpha = 0;86 for(j = 1; j <= (nbar - 1); j++)87 {88 alpha += (*(sf + j - 1)) * cos( PI * j * (dspDouble)(2 * (i - (N/2)) + 1) /N );89 }90 *(result + i) = 1 + 2 *alpha;91

92 }93 }94 *w =result;95 free(sf);96

97 returnDSP_SUCESS;98

99 }100

101

102 /*

103 *函数名：triangularWin104 *说明：计算三角窗函数105 *输入：106 *输出：107 *返回：108 *调用：109 *其它：用过以后，需要手动释放掉*w的内存空间110 * 调用示例：ret = triangularWin(99, &w);111 */

112 dspErrorStatus triangularWin(dspUint_16 N, dspDouble **w)113 {114 dspDouble *ptr;115 dspUint_16 i;116

117 ptr = (dspDouble *)malloc(N * sizeof(dspDouble));118 if(ptr ==NULL)119 returnDSP_ERROR;120

121

122 /*阶数为奇*/

123 if((N % 2) == 1)124 {125 for(i = 0; i < ((N - 1)/2); i++)126 {127 *(ptr + i) = 2 * (dspDouble)(i + 1) / (N + 1);128 }129 for(i = ((N - 1)/2); i < N; i++)130 {131 *(ptr + i) = 2 * (dspDouble)(N - i) / (N + 1);132 }133 }134 /*阶数为偶*/

135 else

136 {137 for(i = 0; i < (N/2); i++)138 {139 *(ptr + i) = (i + i + 1) * (dspDouble)1 /N;140 }141 for(i = (N/2); i < N; i++)142 {143 *(ptr + i) = *(ptr + N - 1 -i);144 }145 }146 *w =ptr;147

148 returnDSP_SUCESS;149 }150

151 /*

152 *函数名：tukeyWin153 *说明：计算tukey窗函数154 *输入：155 *输出：156 *返回：linSpace()157 *调用：158 *其它：用过以后，需要手动释放掉*w的内存空间159 * 调用示例：ret = tukeyWin(99, 0.5, &w);160 */

161 dspErrorStatus tukeyWin(dspUint_16 N, dspDouble r, dspDouble **w)162 {163 dspErrorStatus retErrorStatus;164 dspUint_16 index;165 dspDouble *x,*result,*retPtr;166 dspDouble alpha;167

168 retErrorStatus = linSpace(0, 1, N, &x);169 if(retErrorStatus ==DSP_ERROR)170 returnDSP_ERROR;171

172 result = (dspDouble *)malloc(N * sizeof(dspDouble));173 if(result ==NULL)174 returnDSP_ERROR;175

176 /*r <= 0 就是矩形窗*/

177 if(r <= 0)178 {179 retErrorStatus = rectangularWin(N, &retPtr);180 if(retErrorStatus ==DSP_ERROR)181 returnDSP_ERROR;182 /*将数据拷出来以后，释放调用的窗函数的空间*/

183 memcpy(result, retPtr, ( N * sizeof(dspDouble)));184 free(retPtr);185 }186 /*r >= 1 就是汉宁窗*/

187 else if(r >= 1)188 {189 retErrorStatus = hannWin(N, &retPtr);190 if(retErrorStatus ==DSP_ERROR)191 returnDSP_ERROR;192 /*将数据拷出来以后，释放调用的窗函数的空间*/

193 memcpy(result, retPtr, ( N * sizeof(dspDouble)));194 free(retPtr);195 }196 else

197 {198 for(index = 0; index < N; index++)199 {200 alpha = *(x +index);201 if(alpha < (r/2))202 {203 *(result + index) = (dspDouble)(1 + cos( 2 * PI * (dspDouble)(alpha - (dspDouble)r/2)/r))/2;204 }205 else if((alpha >= (r/2)) && (alpha

210 {211 *(result + index) = (dspDouble)(1 + cos( 2 * PI * (dspDouble)(alpha - 1 + (dspDouble)r/2)/r))/2;212 }213

214 }215 }216

217 free(x);218

219 *w =result;220

221 returnDSP_SUCESS;222

223 }224

225 /*

226 *函数名：bartlettWin227 *说明：计算bartlettWin窗函数228 *输入：229 *输出：230 *返回：231 *调用：232 *其它：用过以后，需要手动释放掉*w的内存空间233 * 调用示例：ret = bartlettWin(99, &w);234 */

235 dspErrorStatus bartlettWin(dspUint_16 N, dspDouble **w)236 {237 dspDouble *ret;238 dspUint_16 n;239

240 ret = (dspDouble *)malloc(N * sizeof(dspDouble));241 if(ret ==NULL)242 returnDSP_ERROR;243

244 for(n = 0; n < ( N - 1 ) / 2; n++)245 {246 *(ret + n) = 2 * (dspDouble)n / (N - 1);247 }248

249 for(n = ( N - 1 ) / 2; n < N; n++)250 {251 *(ret + n) = 2 - 2 * (dspDouble)n / (( N - 1));252 }253

254 *w =ret;255

256 returnDSP_SUCESS;257 }258

259 /*

260 *函数名：bartLettHannWin261 *说明：计算bartLettHannWin窗函数262 *输入：263 *输出：264 *返回：265 *调用：266 *其它：用过以后，需要手动释放掉*w的内存空间267 * 调用示例：ret = bartLettHannWin(99, &w);268 */

269 dspErrorStatus bartLettHannWin(dspUint_16 N, dspDouble **w)270 {271 dspUint_16 n;272 dspDouble *ret;273

274 ret = (dspDouble *)malloc(N * sizeof(dspDouble));275 if(ret ==NULL)276 returnDSP_ERROR;277 /*奇*/

278 if(( N % 2 ) == 1)279 {280 for(n = 0; n < N; n++)281 {282 *(ret + n) = 0.62 - 0.48 * myAbs( ( (dspDouble)n / ( N - 1 ) ) - 0.5 ) + 0.38 * cos( 2 * PI * ( ((dspDouble)n / ( N - 1 ) ) - 0.5) );283 }284 for(n = 0; n < (N-1)/2; n++)285 {286 *(ret + n) = *(ret + N - 1 -n);287 }288 }289 /*偶*/

290 else

291 {292 for(n = 0; n < N; n++)293 {294 *(ret + n) = 0.62 - 0.48 * myAbs( ( (dspDouble)n / ( N - 1 ) ) - 0.5 ) + 0.38 * cos( 2 * PI * ( ((dspDouble)n / ( N - 1 ) ) - 0.5) );295 }296 for(n = 0; n < N/2; n++)297 {298 *(ret + n) = *(ret + N -1 -n);299 }300 }301

302 *w =ret;303

304 returnDSP_SUCESS;305

306 }307

308 /*

309 *函数名：blackManWin310 *说明：计算blackManWin窗函数311 *输入：312 *输出：313 *返回：314 *调用：315 *其它：用过以后，需要手动释放掉*w的内存空间316 * 调用示例：ret = blackManWin(99, &w);317 */

318 dspErrorStatus blackManWin(dspUint_16 N, dspDouble **w)319 {320 dspUint_16 n;321 dspDouble *ret;322 ret = (dspDouble *)malloc(N * sizeof(dspDouble));323 if(ret ==NULL)324 returnDSP_ERROR;325

326 for(n = 0; n < N; n++)327 {328 *(ret + n) = 0.42 - 0.5 * cos(2 * PI * (dspDouble)n / ( N - 1 )) + 0.08 * cos( 4 * PI * ( dspDouble )n / ( N - 1) );329 }330

331 *w =ret;332

333 returnDSP_SUCESS;334 }335

336 /*

337 *函数名：blackManHarrisWin338 *说明：计算blackManHarrisWin窗函数339 *输入：340 *输出：341 *返回：342 *调用：343 *其它：用过以后，需要手动释放掉*w的内存空间344 * 调用示例：ret = blackManHarrisWin(99, &w);345 * minimum 4-term Blackman-harris window -- From Matlab346 */

347 dspErrorStatus blackManHarrisWin(dspUint_16 N, dspDouble **w)348 {349 dspUint_16 n;350 dspDouble *ret;351

352 ret = (dspDouble *)malloc(N * sizeof(dspDouble));353 if(ret ==NULL)354 returnDSP_ERROR;355

356 for(n = 0; n < N; n++)357 {358 *(ret + n) = BLACKMANHARRIS_A0 - BLACKMANHARRIS_A1 * cos( 2 * PI * (dspDouble)n / (N) ) +\359 BLACKMANHARRIS_A2 * cos( 4 * PI * (dspDouble)n/ (N) ) -\360 BLACKMANHARRIS_A3 * cos( 6 * PI * (dspDouble)n/(N) );361 }362

363 *w =ret;364

365 returnDSP_SUCESS;366 }367

368 /*

369 *函数名：bohmanWin370 *说明：计算bohmanWin窗函数371 *输入：372 *输出：373 *返回：374 *调用：375 *其它：用过以后，需要手动释放掉*w的内存空间376 * 调用示例：ret = bohmanWin(99, &w);377 */

378 dspErrorStatus bohmanWin(dspUint_16 N, dspDouble **w)379 {380 dspUint_16 n;381 dspDouble *ret;382 dspDouble x;383 ret = (dspDouble *)malloc(N * sizeof(dspDouble));384 if(ret ==NULL)385 returnDSP_ERROR;386

387 for(n = 0; n < N; n++)388 {389 x = -1 + n * (dspDouble)2 / ( N - 1) ;390 /*取绝对值*/

391 x = x >= 0 ? x : ( x * ( -1) );392 *(ret + n) = ( 1 - x ) * cos( PI * x) + (dspDouble)(1 / PI) * sin( PI *x);393 }394

395 *w =ret;396

397 returnDSP_SUCESS;398 }399

400 /*

401 *函数名：chebyshevWin402 *说明：计算chebyshevWin窗函数403 *输入：404 *输出：405 *返回：406 *调用：407 *其它：用过以后，需要手动释放掉*w的内存空间408 * 调用示例：ret = chebyshevWin(99,100, &w);409 */

410 dspErrorStatus chebyshevWin(dspUint_16 N, dspDouble r, dspDouble **w)411 {412 dspUint_16 n,index;413 dspDouble *ret;414 dspDouble x, alpha, beta, theta, gama;415

416 ret = (dspDouble *)malloc(N * sizeof(dspDouble));417 if(ret ==NULL)418 returnDSP_ERROR;419

420

421 /*10^(r/20)*/

422 theta = pow((dspDouble)10, (dspDouble)(myAbs(r)/20));423 beta = pow(cosh(acosh(theta)/(N - 1)),2);424 alpha = 1 - (dspDouble)1 /beta;425

426 if((N % 2) == 1)427 {428 /*计算一半的区间*/

429 for( n = 1; n < ( N + 1 ) / 2; n++)430 {431 gama = 1;432 for(index = 1; index < n; index++)433 {434 x = index * (dspDouble)( N - 1 - 2 * n + index) /(( n - index ) * (n + 1 -index));435 gama = gama * alpha * x + 1;436 }437 *(ret + n) = (N - 1) * alpha *gama;438 }439

440 theta = *( ret + (N - 1)/2);441 *ret = 1;442

443 for(n = 0; n < ( N + 1 ) / 2; n++)444 {445 *(ret + n) = (dspDouble)(*(ret + n)) /theta;446 }447

448 /*填充另一半*/

449 for(; n < N; n++)450 {451 *(ret + n) = ret[N - n - 1];452 }453 }454 else

455 {456 /*计算一半的区间*/

457 for( n = 1; n < ( N + 1 ) / 2; n++)458 {459 gama = 1;460 for(index = 1; index < n; index++)461 {462 x = index * (dspDouble)( N - 1 - 2 * n + index) /(( n - index ) * (n + 1 -index));463 gama = gama * alpha * x + 1;464 }465 *(ret + n) = (N - 1) * alpha *gama;466 }467

468 theta = *( ret + (N/2) - 1);469 *ret = 1;470

471 for(n = 0; n < ( N + 1 ) / 2; n++)472 {473 *(ret + n) = (dspDouble)(*(ret + n)) /theta;474 }475

476 /*填充另一半*/

477 for(; n < N; n++)478 {479 *(ret + n) = ret[N - n - 1];480 }481 }482

483

484 *w =ret;485

486 returnDSP_SUCESS;487 }488

489 /*

490 *函数名：flatTopWin491 *说明：计算flatTopWin窗函数492 *输入：493 *输出：494 *返回：495 *调用：496 *其它：用过以后，需要手动释放掉*w的内存空间497 * 调用示例：ret = flatTopWin(99, &w);498 */

499 dspErrorStatus flatTopWin(dspUint_16 N, dspDouble **w)500 {501 dspUint_16 n;502 dspDouble *ret;503 ret = (dspDouble *)malloc(N * sizeof(dspDouble));504 if(ret ==NULL)505 returnDSP_ERROR;506

507 for(n = 0; n < N; n++)508 {509 *(ret + n) = FLATTOPWIN_A0 - FLATTOPWIN_A1 * cos(2 * PI * (dspDouble)n / (N - 1)) +\510 FLATTOPWIN_A2 * cos(4 * PI * (dspDouble)n / (N - 1)) -\511 FLATTOPWIN_A3 * cos(6 * PI * (dspDouble)n / (N - 1)) +\512 FLATTOPWIN_A4 * cos(8 * PI * (dspDouble)n / (N - 1));513 }514

515 *w =ret;516

517 returnDSP_SUCESS;518 }519

520

521 /*

522 *函数名：gaussianWin523 *说明：计算gaussianWin窗函数524 *输入：525 *输出：526 *返回：527 *调用：528 *其它：用过以后，需要手动释放掉*w的内存空间529 * 调用示例：ret = gaussianWin(99,2.5, &w);530 */

531 dspErrorStatus gaussianWin(dspUint_16 N, dspDouble alpha, dspDouble **w)532 {533 dspUint_16 n;534 dspDouble k, beta, theta;535 dspDouble *ret;536

537 ret = (dspDouble *)malloc(N * sizeof(dspDouble));538 if(ret ==NULL)539 returnDSP_ERROR;540

541 for(n =0; n < N; n++)542 {543 if((N % 2) == 1)544 {545 k = n - (N - 1)/2;546 beta = 2 * alpha * (dspDouble)k / (N - 1);547 }548 else

549 {550 k = n - (N)/2;551 beta = 2 * alpha * (dspDouble)k / (N - 1);552 }553

554 theta = pow(beta, 2);555 *(ret + n) = exp((-1) * (dspDouble)theta / 2);556 }557

558 *w =ret;559

560 returnDSP_SUCESS;561 }562

563 /*

564 *函数名：hammingWin565 *说明：计算hammingWin窗函数566 *输入：567 *输出：568 *返回：569 *调用：570 *其它：用过以后，需要手动释放掉*w的内存空间571 * 调用示例：ret = hammingWin(99, &w);572 */

573 dspErrorStatus hammingWin(dspUint_16 N, dspDouble **w)574 {575 dspUint_16 n;576 dspDouble *ret;577 ret = (dspDouble *)malloc(N * sizeof(dspDouble));578 if(ret ==NULL)579 returnDSP_ERROR;580

581 for(n = 0; n < N; n++)582 {583 *(ret + n) = 0.54 - 0.46 * cos (2 * PI * ( dspDouble )n / ( N - 1) );584 }585

586 *w =ret;587

588 returnDSP_SUCESS;589 }590

591 /*

592 *函数名：hannWin593 *说明：计算hannWin窗函数594 *输入：595 *输出：596 *返回：597 *调用：598 *其它：用过以后，需要手动释放掉*w的内存空间599 * 调用示例：ret = hannWin(99, &w);600 */

601 dspErrorStatus hannWin(dspUint_16 N, dspDouble **w)602 {603 dspUint_16 n;604 dspDouble *ret;605 ret = (dspDouble *)malloc(N * sizeof(dspDouble));606 if(ret ==NULL)607 returnDSP_ERROR;608

609 for(n = 0; n < N; n++)610 {611 *(ret + n) = 0.5 * ( 1 - cos( 2 * PI * (dspDouble)n / (N - 1)));612 }613

614 *w =ret;615

616 returnDSP_SUCESS;617 }618

619 /*

620 *函数名：kaiserWin621 *说明：计算kaiserWin窗函数622 *输入：623 *输出：624 *返回：625 *调用：besseli()第一类修正贝塞尔函数626 *其它：用过以后，需要手动释放掉*w的内存空间627 * 调用示例：ret = kaiserWin(99, 5, &w);628 */

629 dspErrorStatus kaiserWin(dspUint_16 N, dspDouble beta, dspDouble **w)630 {631 dspUint_16 n;632 dspDouble *ret;633 dspDouble theta;634

635 ret = (dspDouble *)malloc(N * sizeof(dspDouble));636 if(ret ==NULL)637 returnDSP_ERROR;638

639 for(n = 0; n < N; n++)640 {641 theta = beta * sqrt( 1 - pow( ( (2 * (dspDouble)n/(N -1)) - 1),2) );642 *(ret + n) = (dspDouble)besseli(0, theta, BESSELI_K_LENGTH) / besseli(0, beta, BESSELI_K_LENGTH);643 }644

645 *w =ret;646

647 returnDSP_SUCESS;648 }649

650 /*

651 *函数名：nuttalWin652 *说明：计算nuttalWin窗函数653 *输入：654 *输出：655 *返回：656 *调用：657 *其它：用过以后，需要手动释放掉*w的内存空间658 * 调用示例：ret = nuttalWin(99, &w);659 */

660 dspErrorStatus nuttalWin(dspUint_16 N, dspDouble **w)661 {662 dspUint_16 n;663 dspDouble *ret;664

665 ret = (dspDouble *)malloc(N * sizeof(dspDouble));666 if(ret ==NULL)667 returnDSP_ERROR;668

669 for(n = 0; n < N; n++)670 {671 *(ret + n) =NUTTALL_A0 - NUTTALL_A1 * cos(2 * PI * (dspDouble)n / (N - 1)) +\672 NUTTALL_A2 * cos(4 * PI * (dspDouble)n / (N - 1)) -\673 NUTTALL_A3 * cos(6 * PI * (dspDouble)n / (N - 1));674

675 }676

677 *w =ret;678

679 returnDSP_SUCESS;680 }681

682 /*

683 *函数名：parzenWin684 *说明：计算parzenWin窗函数685 *输入：686 *输出：687 *返回：688 *调用：689 *其它：用过以后，需要手动释放掉*w的内存空间690 * 调用示例：ret = parzenWin(99, &w);691 */

692 dspErrorStatus parzenWin(dspUint_16 N, dspDouble **w)693 {694 dspUint_16 n;695 dspDouble *ret;696 dspDouble alpha,k;697

698 ret = (dspDouble *)malloc(N * sizeof(dspDouble));699 if(ret ==NULL)700 returnDSP_ERROR;701

702 if(( N % 2) == 1)703 {704 for(n = 0; n < N; n++)705 {706 k = n - (N - 1) / 2;707 alpha = 2 * (dspDouble)myAbs(k) /N;708 if(myAbs(k) <= (N - 1) / 4)709 {710 *(ret + n) = 1 - 6 * pow(alpha,2) + 6 * pow(alpha, 3);711 }712 else

713 {714 *(ret + n) = 2 * pow( (1 - alpha), 3);715 }716

717 }718 }719 else

720 {721 for(n = 0; n < N; n++)722 {723 k = n - (N - 1) / 2;724 alpha = 2 * (dspDouble)myAbs(k) /N;725 if(myAbs(k) <= (dspDouble)(N -1) / 4)726 {727 *(ret + n) = 1 - 6 * pow(alpha,2) + 6 * pow(alpha, 3);728 }729 else

730 {731 *(ret + n) = 2 * pow( (1 - alpha), 3);732 }733

734 }735 }736

737

738

739 *w =ret;740

741 returnDSP_SUCESS;742 }743

744 /*

745 *函数名：rectangularWin746 *说明：计算rectangularWin窗函数747 *输入：748 *输出：749 *返回：750 *调用：751 *其它：用过以后，需要手动释放掉*w的内存空间752 * 调用示例：ret = rectangularWin(99, &w);753 */

754 dspErrorStatus rectangularWin(dspUint_16 N, dspDouble **w)755 {756 dspUint_16 n;757 dspDouble *ret;758

759 ret = (dspDouble *)malloc(N * sizeof(dspDouble));760 if(ret ==NULL)761 returnDSP_ERROR;762

763 for(n = 0; n < N; n++)764 {765 *(ret + n) = 1;766 }767

768 *w =ret;769

770 returnDSP_SUCESS;771 }

c语言滑窗法_窗函数的C语言实现相关推荐

c语言滑窗法_滑动窗口算法（一）
某日事不多,点开sentinel-core代码学习,想看看qps.rt等是怎么统计的. 点开StatisticSlot类,发现里面是用DefaultNode增加qps,然后尝试点开 DefaultNo ...
python 滑窗法检测房颤分类
python 滑窗法检测房颤分类判断信号的峰值间的距离是否相差较少废话不说,直接上程序!记得点赞!!!!!! 思路主要是使用滑窗找到最大值对应的位置,最大值对应的位置相差间距求出来,相邻较小的位置 ...
c语言tab什么意思_我的C语言入门笔记。
点击上方"我要学编程",选择"置顶/星标公众号"福利干货,第一时间送达! C语言入门 C语言一经出现就以其功能丰富.表达能力强.灵活方便.应用面广等特点迅速在全 ...
c语言tab什么意思_我的C语言入门笔记~!
C语言入门 C语言一经出现就以其功能丰富.表达能力强.灵活方便.应用面广等特点迅速在全世界普及和推广.C语言不但执行效率高而且可移植性好,可以用来开发应用软件.驱动.操作系统等.C语言也是其它众多高级 ...
c语言模拟java面向对象_面向对象设计模式C语言实现.PDF
第15卷第l1期微机发展 V01．15NO．11 2005年11月 I)evdopment NOV．2()()5 Micrtxx)mpuler 面向对象设计模式的C语言实现朱进 (东南大学软件学院 ...
c语言不安全库_为什么和其他语言相比C语言是快速的语言？
点击上方蓝字关注我哦- 01 前言初入门的我们经常听见别人说"真正的程序员用C语言编程,C是最快的语言因为它是最靠近及其底层的语言."那么和其他语言相比C语言到底有什么特别的呢? ...
c语言合法自定义标识符_计算机二级C语言干货来了
16个考点大盘点 C语言基本知识 [考点1] C程序 C语言程序结构有三种:顺序结构,循环结构(三个循环结构),选择结构(if和switch) [考点2] main函数每个C语言程序中main函数是 ...
c语言遍历文件内容_跨平台的C语言网络框架库acl
acl概述 acl (全称Advanced C Library)是一个跨平台(支持LINUX,WIN32,Solaris,MacOS,FreeBSD)的网络通信库及服务器编程框架,同时提供更多的实用功 ...
c语言解析sql语句_如何在C语言里面执行SQL语句？
一.为什么要在C语言程序中执行SQL语句? 在C语言程序中执行SQL语句的原因有以下几个: (1)程序需要获取数据库中某数据表的字段值,并对这些字段值进行解析以执行后续操作. (2)程序需要更新数据库 ...
c语言算术平均滤波法_基本C语言滤波算法
11种软件滤波方法的示例程序假定从8位AD中读取数据(如果是更高位的AD可定义数据类型为int),子程序为get_ad(); 1.限副滤波 /* A值可根据实际情况调整 value为有效值,new ...

c语言滑窗法_窗函数的C语言实现

c语言滑窗法_窗函数的C语言实现相关推荐

最新文章

热门文章

c语言 滑窗法_窗函数的C语言实现

c语言 滑窗法_窗函数的C语言实现相关推荐

最新文章

热门文章

c语言滑窗法_窗函数的C语言实现

c语言滑窗法_窗函数的C语言实现相关推荐