ທິດທາງ Preprocessor ໃນ C Programming


ການນໍາສະເຫນີ

ໃນເວລາທີ່ພວກເຮົາຂຽນໂປແກຼມ, ມັນບໍ່ແມ່ນເລື່ອງກົງໄປກົງມາ. ພວກເຮົາຈະຈັດການກັບຂໍ້ຄົງຄ້າງ, ບາງເງື່ອນໄຂທີ່ໄດ້ ກຳ ນົດໄວ້, ໜ້າ ທີ່ແລະອື່ນໆ. ຕົວຢ່າງ ໜຶ່ງ ແມ່ນການອ່ານການປ້ອນຂໍ້ມູນຈາກວັດສະດຸປ້ອນມາດຕະຖານ, ເຊັ່ນ; ຈາກແປ້ນພິມຮຽກຮ້ອງໃຫ້ມີຫນ້າທີ່ບາງຢ່າງທີ່ອ່ານປຸ່ມທີ່ຜູ້ໃຊ້ໄດ້ກົດເຂົ້າຫລືກົດປຸ່ມ. ແທນທີ່ຈະຂຽນຟັງຊັນໃນແຕ່ລະໂປແກຼມເພື່ອອ່ານຂໍ້ມູນທີ່ຜູ້ໃຊ້ໄດ້ເຂົ້າມາ, ພວກເຮົາສາມາດຂຽນຟັງຊັນມາດຕະຖານ / ທຳ ມະດາເພື່ອອ່ານຂໍ້ມູນທີ່ໃສ່ຈາກແປ້ນພິມ, ໝາຍ ຄວາມວ່າ; scanf (). ຟັງຊັນນີ້ຈະຖືກເກັບຮັກສາໄວ້ໃນຫໍສະມຸດຜົນຜະລິດວັດສະດຸປ້ອນມາດຕະຖານ, ເຊິ່ງສາມາດໃສ່ເຂົ້າໃນໂປແກມໂດຍໃຊ້ ຄຳ ສັ່ງ preprocessor. ພວກເຮົາຍັງເອີ້ນ ຄຳ ສັ່ງແນະ ນຳ ກ່ຽວກັບຜູ້ ອຳ ນວຍການນີ້ເປັນແຟ້ມຫົວ. ເມື່ອໃດກໍ່ຕາມນັກຂຽນລວບລວມໂປແກຼມ, ມັນຈະປ່ຽນລະຫັດທັງ ໝົດ ໃນແຟ້ມຫົວເຂົ້າໃນໂປແກຼມປັດຈຸບັນກ່ອນແລະຫຼັງຈາກນັ້ນລວບລວມໂປຣແກຣມ. ດັ່ງນັ້ນເມື່ອໂປແກຼມເອີ້ນວ່າ scanf function ມັນຈະໄດ້ຮັບ ຄຳ ນິຍາມຟັງຊັນຈາກແຟ້ມຫົວ. ດ້ວຍວິທີນີ້, ມັນຊ່ວຍໃນການ ນຳ ໃຊ້ ໜ້າ ທີ່ທີ່ໄດ້ ກຳ ນົດໄວ້ໃນທຸກໆໂປແກຼມອື່ນ.

ເຊັ່ນດຽວກັນ, ສົມມຸດວ່າໃນໂຄງການ ໜຶ່ງ ພວກເຮົາຕ້ອງໄດ້ເພີ່ມເງິນເດືອນໃຫ້ພະນັກງານ 10%. ນີ້ແມ່ນຄ່ານິຍົມທີ່ພວກເຮົາ ກຳ ລັງຈະຂື້ນເງິນເດືອນເພີ່ມ. ແຕ່ເມື່ອເຮົາຂຽນໂປແກຼມ, ພວກເຮົາຈະຍາກໃນການເຂົ້າລະຫັດປັດໄຈທີ່ເພີ່ມຂື້ນນີ້. ສົມມຸດວ່າມັນຈະມີຫລາຍໆບ່ອນທີ່ພວກເຮົາຈະເພີ່ມຄຸນຄ່າ. ໂປແກຼມນີ້ອາດຈະຖືກ ນຳ ໃຊ້ໂດຍຜູ້ໃຊ້ຫຼາຍໆຄົນຫຼືຫຼາຍຄັ້ງເພື່ອເພີ່ມເງິນເດືອນ. ສົມມຸດວ່າຈະເປັນແນວໃດຖ້າອັດຕາສ່ວນເພີ່ມຂື້ນນີ້ປ່ຽນແປງ? ພວກເຮົາຕ້ອງປ່ຽນແປງໂຄງການທັງ ໝົດ, ບ່ອນໃດກໍ່ຕາມການຂຶ້ນເງິນເດືອນກໍ່ຈະ ສຳ ເລັດ. ແທນທີ່ຈະເຮັດສິ່ງນີ້, ຖ້າພວກເຮົາໄດ້ ກຳ ນົດອັດຕາສ່ວນເພີ່ມຂື້ນນີ້ໃນຕົວແປແລະ ໝາຍ ວ່າມັນຄົງ, ພວກເຮົາສາມາດເອົາຊະນະຄວາມຫຍຸ້ງຍາກໃນການປ່ຽນໂປຣແກຣມທັງ ໝົດ ເມື່ອອັດຕາສ່ວນນີ້ປ່ຽນແປງ. ແຕ່ຖ້າພວກເຮົາ ກຳ ນົດຕົວແປທີ່ຄົງທີ່ແລະໃຊ້ມັນເຂົ້າໃນໂປແກຼມ, ເມື່ອຜູ້ລວບລວມໂປແກຼມ, ມັນຈະບໍ່ປ່ຽນແທນຄ່າຕົວປ່ຽນຄ່າຄົງທີ່ໃນເວລາລວບລວມ ມັນຈະຖືກທົດແທນໃນເວລາແລ່ນເປັນຕົວແປທີ່ມີທີ່ຢູ່ຄວາມ ຈຳ. ນີ້ແມ່ນວຽກທີ່ໃຊ້ເວລາໃນຂະນະທີ່ ດຳ ເນີນການ. ຖ້າພວກເຮົາມີສິ່ງ ອຳ ນວຍຄວາມສະດວກໃນການເກັບຮັກສາມູນຄ່າໃນຕົວປ່ຽນຄົງທີ່ແລະເພື່ອທົດແທນຄ່າຂອງຕົວແປນີ້ເປັນຄ່າຕົວມັນເອງແທນທີ່ຈະປ່ຽນແທນມັນເປັນຕົວແປກັບທີ່ຢູ່ຂອງຄວາມຊົງ ຈຳ, ເວລາການປະຕິບັດຈະ ໜ້ອຍ ຫຼາຍ. ສຳ ລັບຈຸດປະສົງນີ້ພວກເຮົາສາມາດ ນຳ ໃຊ້ ຄຳ ສັ່ງແນະ ນຳ ຂອງຜູ້ ດຳ ເນີນງານ.

ທິດທາງຂອງຜູ້ຜະລິດ

ຄຳ ສັ່ງແນະ ນຳ ຂອງໂປແກຼມ Preprocessor ແມ່ນເຄື່ອງມືທົດແທນຕົວ ໜັງ ສື, ຖືກ ນຳ ໃຊ້ເຂົ້າໃນໂປແກຼມເພື່ອແທນຂໍ້ຄວາມໂດຍມັນມີຄ່າ. ມັນແຕກຕ່າງຈາກຕົວແປ. ເມື່ອໃດກໍ່ຕາມຕົວແປໄດ້ຖືກ ນຳ ໃຊ້ເຂົ້າໃນໂປແກຼມ, ນັກລວບລວມເຂົ້າໃຈມັນວ່າມັນເປັນຄ່າທີ່ເກັບໄວ້ໃນທີ່ຢູ່ຂອງ ໜ່ວຍ ຄວາມ ຈຳ ບາງບ່ອນ. ແຕ່ເມື່ອ ຄຳ ສັ່ງແນະ ນຳ ຂອງໂປເຈັກຖືກ ນຳ ໃຊ້ເຂົ້າໃນໂປແກຼມ, ຂໍ້ຄວາມຫລືຊື່ຂອງ ຄຳ ສັ່ງແນະ ນຳ ຂອງໂປເຊດເຊີບໍ່ໄດ້ຖືວ່າເປັນຄ່າຫລືລະຫັດບາງຢ່າງໃນ ໜ່ວຍ ຄວາມ ຈຳ. ຜູ້ລວບລວມຂໍ້ມູນແທນພວກມັນໂດຍມູນຄ່າຕົວຈິງຂອງມັນໃນໂປແກມແລະຫຼັງຈາກນັ້ນລວບລວມໂປແກຼມ.

ຍົກຕົວຢ່າງ, ສົມມຸດວ່າພວກເຮົາຕ້ອງໄດ້ເພີ່ມເງິນເດືອນໃຫ້ໄດ້ 10% ແລະພວກເຮົາໄດ້ ກຳ ນົດຄ່າຄົງທີ່ນີ້ເປັນຕົວແປ. ຫຼັງຈາກນັ້ນ:

const float SAL_INCRE= 0.1;

ຖ້າພວກເຮົາມີລະຫັດໃດໆໃນໂປແກມໂດຍໃຊ້ຕົວປ່ຽນຂ້າງເທິງ, ຫຼັງຈາກນັ້ນເມື່ອນັກລວບລວມໂປແກຼມ, ມັນຈະເຫັນລະຫັດດັ່ງລຸ່ມນີ້:

intSal = intSal * SAL_INCRE; →ຕົວລວບລວມຂໍ້ມູນຈະແທນມູນຄ່າຂອງ SAL_INCRE ໃນເວລາແລ່ນ.

ສົມມຸດວ່າພວກເຮົາໄດ້ເຮັດ SAL_INCRE ນີ້ເປັນ ຄຳ ສັ່ງ preprocessor ແທນທີ່ຈະມີຕົວປ່ຽນແປງຄົງທີ່, ຫຼັງຈາກນັ້ນນັກລວບລວມຂໍ້ມູນເຫັນຢູ່ຂ້າງເທິງສູດດັ່ງລຸ່ມນີ້:

intSal = intSal * 0.1;

ນັ້ນ ໝາຍ ຄວາມວ່າ, ທຸກເວລາ ຄຳ ສັ່ງແນະ ນຳ ຂອງຜູ້ ດຳ ເນີນການຖືກ ນຳ ໃຊ້ມັນແທນຊື່ໂດຍມູນຄ່າຕົວຈິງຢູ່ທຸກບ່ອນທີ່ມັນຖືກ ນຳ ໃຊ້.

ຄຳ ສັ່ງທິດທາງ preprocessor ມີຫລາຍປະເພດແຕກຕ່າງກັນ - ຄົງທີ່, ມະຫາພາກ, ເງື່ອນໄຂ, ໜ້າ ທີ່ແລະອື່ນໆ. ຄຳ ສັ່ງແນະ ນຳ ຂອງຜູ້ ອຳ ນວຍການເລີ່ມຕົ້ນແມ່ນເລີ່ມຕົ້ນດ້ວຍສັນຍາລັກ '#', ຕິດຕາມດ້ວຍ ຄຳ ສັ່ງ ຄຳ ສັ່ງ preprocessor. ຍົກ​ຕົວ​ຢ່າງ,

#include <stdio.h>// includes header file into current program
#include <string.h> // includes header file into current program
#define SAL_INCRE 0.1 //defines constant value
#define MAX_ARRAY_SIZE 15 // defines maximum array size
#define SQUAR (x) (x*x) //defines the formula for finding the square of a number

#ifndef MESSAGE // defines the value for MESSAGE if this macro is not defined, else it uses the old macro value
	#define MESSAGE "Preprocessor Directive Example" 
#endif

ຈາກຕົວຢ່າງຂ້າງເທິງ, ພວກເຮົາສາມາດເຂົ້າໃຈວ່າທິດທາງຂອງຜູ້ປະຕິບັດແມ່ນມີປະໂຫຍດຫຼາຍ
  • ການພັດທະນາງ່າຍຕໍ່ການພັດທະນາ, ງ່າຍຕໍ່ການອ່ານແລະງ່າຍຕໍ່ການດັດແປງໂປແກຼມຕ່າງໆ.
  • ການຂົນສົ່ງລະຫັດລະຫວ່າງເຄື່ອງທີ່ແຕກຕ່າງກັນ.

#ກໍານົດ

ຄຳ ສັ່ງແນະ ນຳ ກ່ຽວກັບຜູ້ ອຳ ນວຍການນີ້ຖືກ ນຳ ໃຊ້ເພື່ອ ກຳ ນົດຄຸນຄ່າຄົງທີ່ຫລືບາງຂໍ້ຄວາມຫລືບາງສູດຫຼືບາງຕົວແທນມະຫາພາກ.

#define PI 3.14 //defines constant value
#define MAX_ARRAY_SIZE 15 // defines constant value which is used for maximum array size
#define SQUAR (x) (x*x) //defines the formula for finding the square of a number
	#define TRUE TR // redefines TRUE as TR, in the program TR can be used instead of TRUE
#define FALSE FL// redefines FALSE as FL, in the program FL can be used instead of FALSE

ໃນຕົວຢ່າງຂ້າງເທິງ, ສອງ ທຳ ອິດ ກຳ ນົດຄ່າຄົງທີ່. ອັນທີສາມແມ່ນໃຊ້ເພື່ອ ກຳ ນົດຟັງຊັນ SQUARE. ສອງທິດທາງສຸດທ້າຍໄດ້ ກຳ ນົດ TRUE ເປັນ TR ແລະ FALSE ເປັນ FL. ບັນດາຊື່ທີ່ຖືກ ກຳ ນົດນີ້ສາມາດ ນຳ ໃຊ້ເຂົ້າໃນໂປແກຼມໄດ້ທຸກຄັ້ງທີ່ພວກເຮົາຕ້ອງການໃຊ້ TRUE ຫລື FALSE. ນີ້ຈະເປັນປະໂຫຍດເມື່ອພວກເຮົາມີຄວາມຍາວຫຼືຊື່ຫຍຸ້ງຍາກໃນໂປແກມແລະການ ກຳ ນົດຊື່ນີ້ຈະເຮັດໃຫ້ລະຫັດງ່າຍດາຍແລະຊ່ວຍໃຫ້ນັກພັດທະນາຂຽນລະຫັດໄດ້ໄວ.

#ສຸດຍອດ

ສິ່ງນີ້ຖືກ ນຳ ໃຊ້ເພື່ອ ກຳ ນົດຄຸນຄ່າຫລືສູດຫຼື ໜ້າ ທີ່ທີ່ໄດ້ ກຳ ນົດໄວ້ກ່ອນ ໜ້າ ນີ້. ມັນເປັນປະໂຫຍດຖ້າພວກເຮົາຕ້ອງ ກຳ ນົດທິດທາງຫລືມະຫາພາກຄືນ ໃໝ່. ຖ້າພວກເຮົາຕ້ອງ ກຳ ນົດມະຫາພາກຄືນ ໃໝ່, ຫຼັງຈາກນັ້ນພວກເຮົາຕ້ອງ ກຳ ນົດມະຫາພາກກ່ອນໂດຍບໍ່ ຈຳ ກັດແລະຫຼັງຈາກນັ້ນໃຫ້ ກຳ ນົດມັນຄືນໂດຍໃຊ້ ຄຳ ນິຍາມ.

#define MAX_ARRAY_SIZE 50 // defines maximum array size for the first time
#undef MAX_ARRAY_SIZE // undefines the MAX_ARRAY_SIZE defined earlier
#define MAX_ARRAY_SIZE 15 // redefines maximum array size

ພວກເຮົາສາມາດ ກຳ ນົດມະຫາພາກທຸກບ່ອນໃນໂປແກມ. ຍົກຕົວຢ່າງ, ພວກເຮົາຕ້ອງໄດ້ເພີ່ມເງິນເດືອນພະນັກງານໃຫ້ໄດ້ 10% ສຳ ລັບບາງພະແນກແລະ ສຳ ລັບສ່ວນທີ່ເຫຼືອຂອງພະແນກມັນ ຈຳ ເປັນຕ້ອງໄດ້ເພີ່ມຂື້ນ 20%. ພວກເຮົາສາມາດ ກຳ ນົດສອງມະຫາພາກທີ່ແຕກຕ່າງກັນໃນສະຖານະການນີ້. ແຕ່ການ ນຳ ໃຊ້ມະຫາພາກດຽວກັນ, ທຳ ອິດພວກເຮົາສາມາດ ກຳ ນົດການເພີ່ມເງິນເດືອນໃຫ້ໄດ້ 10% ແລະປະຕິບັດການຄິດໄລ່ ສຳ ລັບພະແນກເຫຼົ່ານັ້ນ. ຫລັງຈາກນັ້ນພວກເຮົາສາມາດ ກຳ ນົດມູນຄ່າໃຫ້ໄດ້ 20% ໂດຍ ກຳ ນົດແລະ ກຳ ນົດມະຫາພາກ.
#define SAL_INCRE 0.1 //defines constant value
//Perform the calculations for the employees with 10% increment
#undef SAL_INCRE // undefines the SAL_INCRE defined earlier
#define SAL_INCRE 0.2 // redefines maximum array size
//Calculate the salary for rest of the employees

ແຟ້ມຫົວຂໍ້ - #include

ຄຳ ສັ່ງແນະ ນຳ ກ່ຽວກັບໂປແກຼມ preprocessor ນີ້ແມ່ນໃຊ້ເພື່ອລວມເອົາເອກະສານອື່ນເຂົ້າໃນໂປແກຼມປະຈຸບັນ. ໂດຍປົກກະຕິແລ້ວເອກະສານທີ່ຕ້ອງເອົາເຂົ້າໃສ່ຈະຖືກບັນທຶກດ້ວຍການຂະຫຍາຍ '.h'. ພວກເຮົາປະກອບເອກະສານເຂົ້າໃນໂປແກຼມປະຈຸບັນໂດຍໃຊ້ ຄຳ ສັ່ງ preprocessor ດັ່ງລຸ່ມນີ້:

#include <file_name.h> //Used for inbuilt header files

OR
#include "file_name.h" //Used for user defined header files

#include <stdio.h>// includes header file into current program
#include “string.h” // includes header file into current program

ຄຳ ສັ່ງແນະ ນຳ ກ່ຽວກັບຜູ້ຜະລິດຄັ້ງນີ້ຍັງຖືກເອີ້ນວ່າເປັນແຟ້ມຫົວ. ນີ້ແມ່ນຍ້ອນວ່າ, ສຳ ລັບໂປແກຼມໃດທີ່ຈະປະຕິບັດໄດ້, ພວກເຮົາຕ້ອງໄດ້ ນຳ ໃຊ້ບາງ ໜ້າ ທີ່ແລະການ ກຳ ນົດທີ່ໄດ້ ກຳ ນົດໄວ້. ພວກມັນທັງ ໝົດ ຖືກ ກຳ ນົດໄວ້ໃນແຟ້ມຫົວແລະພວກເຂົາຕ້ອງໄດ້ລວມເຂົ້າໃນເອກະສານກ່ອນ. ເມື່ອນັກຂຽນລວບລວມໂປແກຼມ, ມັນຈະຊອກຫາເອກະສານ header ທຳ ອິດໃນລະບົບ (ໂດຍປົກກະຕິແລ້ວໄຟເຫຼົ່ານີ້ຈະຢູ່ໃນໄດເລກະທໍລີຂອງໂປແກຼມເອງ; ອີກຢ່າງ ໜຶ່ງ ມັນຈະຢູ່ໃນ usr / ລວມ / folder).

ເມື່ອເອກະສານ header ຖືກລວມເຂົ້າໃນໂປແກມ, ມັນຖືກຂຽນເປັນລະຫັດ ທຳ ອິດຢູ່ລຸ່ມນີ້. ເມື່ອນັກຂຽນລວບລວມລະຫັດ, ມັນຈະເຫັນແຟ້ມຫົວເປັນລະຫັດທີສອງຢູ່ດ້ານລຸ່ມ. ນັ້ນ ໝາຍ ຄວາມວ່າມັນປ່ຽນແທນເອກະສານ header ດ້ວຍລະຫັດທັງ ໝົດ.

C ອະນຸຍາດໃຫ້ປະກອບມີແຟ້ມຫົວຫຼາຍເທົ່າທີ່ຜູ້ໃຊ້ຕ້ອງການ. ແຟ້ມຫົວດຽວກັນສາມາດຖືກລວມເຂົ້າຫຼາຍກ່ວາ ໜຶ່ງ ຄັ້ງ. ພວກເຮົາໄດ້ເຫັນຢູ່ຂ້າງເທິງວ່າຜູ້ລວບລວມຂໍ້ມູນຈະປ່ຽນແທນເອກະສານ header ໂດຍເນື້ອຫາຂອງມັນ. ເພາະສະນັ້ນເມື່ອນັກຂຽນລວບລວມໂປແກຼມມັນຈະເຫັນຊື່ການເຮັດວຽກດຽວກັນສອງຄັ້ງ, ດັ່ງນັ້ນຈຶ່ງເຮັດໃຫ້ເກີດຄວາມຜິດພາດ. C ບໍ່ອະນຸຍາດໃຫ້ສອງ ໜ້າ ທີ່ມີຊື່ຟັງຊັ່ນດຽວກັນ. ນີ້ສາມາດຫລີກລ້ຽງໄດ້ໂດຍການ ກຳ ນົດແຟ້ມຫົວຂໍ້ໂດຍໃຊ້ syntax #ifndef. ຄຳ ສັ່ງ preprocessor ນີ້ ທຳ ອິດຈະກວດເບິ່ງວ່າຟັງຊັ່ນຫລື ຄຳ ທີ່ຖືກ ກຳ ນົດໄວ້ແລ້ວ, ຖ້າບໍ່ແມ່ນມັນຈະ ກຳ ນົດ ໜ້າ ທີ່. ດັ່ງນັ້ນເມື່ອເອກະສານ header ດຽວກັນຖືກລວມເຂົ້າສອງຄັ້ງ, ມັນຈະເຫັນວ່າ ໜ້າ ທີ່ໄດ້ຖືກ ກຳ ນົດແລ້ວແລະອອກມາ. ດັ່ງນັ້ນໂປແກຼມທັງ ໝົດ ຈະໄດ້ຮັບເອກະສານພຽງແຕ່ຫົວດຽວເທົ່ານັ້ນ.

#include <stdio.h>
#include “test.h”

void main(){
	printf("Testing header files\n");
	test();
}

// test.h
#ifndef test
#define test() 	printf("Within the header file\n")
#endif

ບາງຄັ້ງມັນຈະມີຄວາມຕ້ອງການທີ່ຈະລວມເອົາແຟ້ມຫົວທີ່ແຕກຕ່າງກັນໂດຍອີງໃສ່ເງື່ອນໄຂສະເພາະ. ໃນກໍລະນີດັ່ງກ່າວພວກເຮົາອາດຈະມີ ຄຳ ສັ່ງ # preprocessor ທີ່ຈະລວມເອົາແຟ້ມຫົວ.

#if condition1
	#include"condition1.h"
#elif condition2
	#include"condition2.h"
#elif condition3
	#include"condition3.h"
#endif

ແຕ່ລວມທັງເອກະສານ header ໂດຍໃຊ້ໂປແກຼມ preprocessor ທີ່ມີເງື່ອນໄຂຈະເປັນເລື່ອງທີ່ ໜ້າ ເບື່ອເພາະ ຈຳ ນວນສະພາບການຈະເລີນເຕີບໂຕ. ນອກຈາກນັ້ນ, ມັນກໍ່ສ້າງບັນຫາໃນການເຂົ້າໃຈລະຫັດແລະອາດຈະເຮັດໃຫ້ເກີດການຊໍ້າຄືນຂອງແຟ້ມຫົວຂໍ້ດຽວກັນ. ເພື່ອເອົາຊະນະບັນຫາດັ່ງກ່າວ, C ໃຫ້ ຄຳ ແນະ ນຳ ລວມເຖິງ, ບ່ອນທີ່ພວກເຮົາ ກຳ ນົດມະຫາພາກເຊິ່ງປະກອບມີ header file ເຊິ່ງມີຄວາມ ຈຳ ເປັນ ສຳ ລັບໂປແກຼມ.
#define HEADER_FILE "header_file.h" //defining a macro for the header file

#include HEADER_FILE // this will automatically detect which header file to be included and will include it in the program

#if .. # endif

ນີ້ແມ່ນຄ້າຍຄືກັນກັບຖ້າມີເງື່ອນໄຂ, ແຕ່ວ່າມັນຖືກໃຊ້ເພື່ອປະເມີນການສະແດງອອກຂອງເລກເຕັມຄົງທີ່. ເຊັ່ນດຽວກັນກັບຖ້າເງື່ອນໄຂຂອງສິ່ງອື່ນແລະອື່ນໆຖ້າມີເງື່ອນໄຂ, ມັນກໍ່ມີ #else ແລະ #elif ຕາມ ລຳ ດັບ. ມະຫາພາກ #if ທັງ ໝົດ ຄວນຈົບລົງດ້ວຍ #endif.

#if A>B
	#define “A is greater than B" 
#endif

 
#if A>B
	#define "A is greater than B" 
#else
	#define "A is lesser than B"
#endif

ນີ້ແມ່ນບັນດາທິດທາງຂອງຜູ້ ດຳ ເນີນການກ່ອນທີ່ມີເງື່ອນໄຂງ່າຍດາຍ. ພວກເຮົາຍັງສາມາດມີໂປແກຼມ preprocessor ທີ່ມີຮັງແບບ ສຳ ລັບການລວບລວມເງື່ອນໄຂ.
#if A>B
	#define "A is greater than B" 
#else
	#if B>C
		#define “B is Greater than C”
	#else
		#define “C is Greater than A and B”
	#endif
#endif

#if A>B
	#define "A is greater than B" 
#elif B>C
	#define "B is Greater than C"
#else
	#define"C is Greater than A and B"
#endif

ມາໂຄຣ

Macros ແມ່ນລະຫັດທີ່ ກຳ ນົດໄວ້ກ່ອນເຊິ່ງຈະຖືກປະຕິບັດໂດຍອັດຕະໂນມັດເມື່ອມັນພົບໃນໂປແກຼມ. ມີມະຫາພາກທີ່ໄດ້ ກຳ ນົດໄວ້ພ້ອມທັງມະຫາພາກທີ່ ກຳ ນົດໄວ້ໂດຍຜູ້ໃຊ້. ບາງສ່ວນຂອງມະຫາພາກທີ່ໄດ້ ກຳ ນົດໄວ້ແມ່ນຢູ່ຂ້າງລຸ່ມນີ້. ມະຫາພາກເຫຼົ່ານີ້ບໍ່ສາມາດປ່ຽນແປງແລະສົ່ງຜົນໄດ້ຮັບທີ່ໄດ້ ກຳ ນົດໄວ້ກ່ອນ.

ເຄື່ອງ ໝາຍ ມະຫາພາກທີ່ຖືກ ກຳ ນົດໂດຍຜູ້ໃຊ້ແມ່ນຜູ້ທີ່ຖືກສົນທະນາຂ້າງເທິງເຊັ່ນ: #define, #if, #ifdef, #ifndef, #undef ແລະອື່ນໆ. ເຫຼົ່ານີ້ຖືກ ນຳ ໃຊ້ເພື່ອ ກຳ ນົດກົດລະບຽບແລະເງື່ອນໄຂບາງຢ່າງທີ່ຕ້ອງໄດ້ລວມເຂົ້າໃນໂປແກຼມ. ມະຫາພາກເຫຼົ່ານີ້ບໍ່ ຈຳ ເປັນຕ້ອງ ຈຳ ກັດສາຍດຽວ. ພວກເຮົາສາມາດມີມະຫາພາກ multiline ເຊັ່ນດຽວກັນກັບ macro ຮັງເຊັ່ນ #if .. # elif .. # endif.

Macros ບໍ່ ຈຳ ເປັນຕ້ອງເປັນຊື່ງ່າຍໆຫລືໂທເຄນ. ມັນຍັງສາມາດມີຕົວກໍານົດການ. ຍົກຕົວຢ່າງ, ມະຫາພາກເພື່ອຊອກຫາຮູບສີ່ຫຼ່ຽມມົນຂອງຕົວເລກແມ່ນມະຫາພາກທີ່ມີພາຫະນະ. ມັນຍອມຮັບຕົວເລກທີ່ເປັນພາລາມິເຕີທີ່ຮຽບຮ້ອຍຕ້ອງພົບ.

#define SQUAR (x) (x*x) //defines the formula for finding the square of a number
#define Factorial (N) (N*Factorial (N-1)) //macro to find the factorial of a number

ຜູ້ປະກອບການໂຄງການ

Macros ທີ່ສ້າງຂື້ນໃນ C ຍັງປະກອບດ້ວຍລະຫັດ C, ການສະແດງອອກແລະຜູ້ປະຕິບັດງານ. ມັນໃຊ້ຕົວ ດຳ ເນີນການດຽວກັນທີ່ຖືກ ນຳ ໃຊ້ໂດຍການສະແດງອອກໃນ C, ແຕ່ມັນມີຄວາມ ໝາຍ ທີ່ແຕກຕ່າງກັນໃນເວລາທີ່ໃຊ້ເປັນແມັກໂຄຣ.

Multiline ສືບຕໍ່ Macro (\)

ໃນສະຖານະການທົ່ວໄປ, ຄຳ ແນະ ນຳ ກ່ຽວກັບມະຫາພາກຫລືຜູ້ ກຳ ນົດກ່ອນແມ່ນຂຽນເປັນສາຍດຽວ. ແຕ່ພວກເຮົາສາມາດມີ ຄຳ ນິຍາມ / ຄຳ ສັ່ງທີ່ມີຄວາມຍາວຫຼາຍຫຼືຫຼາຍ. ໃນສະຖານະການດັ່ງກ່າວ, ພວກເຮົາ ຈຳ ເປັນຕ້ອງມີຜູ້ປະກອບການ ຈຳ ນວນ ໜຶ່ງ ທີ່ບອກຜູ້ຂຽນວ່າມະຫາພາກບໍ່ ຈຳ ກັດສາຍດຽວ; ແຕ່ເສັ້ນຕໍ່ໄປກໍ່ແມ່ນສ່ວນ ໜຶ່ງ ຂອງມະຫາພາກດຽວກັນ.

#include <stdio.h>
#define displayEmpName (strName) \
 printf ("Employee name is: %s\n", strName) // definition of macro is in next line

void main(){
	char *strEmpName = "Mathew";

	displayEmpName(strEmpName);
}

ສະຕິງ (#)

Macros ຫຼືທິດທາງ preprocessor ເລີ່ມຕົ້ນດ້ວຍສັນຍາລັກ '#' ທີ່ບົ່ງບອກນັກຂຽນວ່າພວກເຂົາແມ່ນທິດທາງ preprocessor. ມະຫາພາກເຫຼົ່ານີ້ສາມາດມີຕົວ ກຳ ນົດເຊັ່ນກັນ. ເພື່ອເຂົ້າຫາພາລາມິເຕີເຫລົ່ານີ້ພາຍໃນມະຫາພາກສາມາດເຂົ້າເຖິງໄດ້ໂດຍໃຊ້ສັນຍາລັກ '#'. ເມື່ອຕົວກໍານົດການມະຫາພາກເຫຼົ່ານີ້ຖືກເຂົ້າເຖິງພາຍໃນມະຫາພາກໂດຍໃຊ້ '#', ມັນຈະປ່ຽນແທນມັນໂດຍຄ່າຂອງມັນ.

#include <stdio.h>
#define displayEmpName(strName) \
 printf("Employee name is: " #strName) //accessing the macro parameter using stringize

void main(){
	displayEmpName("Robert"); // Double quote is also displayed 
}

ການວາງໂທເຄັນ (##)

ສິ່ງນີ້ຖືກ ນຳ ໃຊ້ເພື່ອສົມທົບສອງຕົວ ກຳ ນົດມະຫາພາກທີ່ແຕກຕ່າງກັນເຂົ້າໃນ ໜຶ່ງ ພາລາມິເຕີ.

#include <stdio.h>
#define empSalary(n) printf("Salary of the employee"#n " is: %d\n", salary##n) // appends the employee number

void main(){
	int salary100 = 1000;
	int salary101= 2000;
	int salary102 = 3000;
	int salary103 = 4000;

	empSalary(100);//employee numbers are passed as parameters
	empSalary(101);
	empSalary(102);
	empSalary(103);
}

ໃນຕົວຢ່າງນີ້, ມະຫາພາກຖືກ ກຳ ນົດໃຫ້ພິມເງິນເດືອນຂອງພະນັກງານ. #n ຄັ້ງ ທຳ ອິດໃນມະຫາພາກແມ່ນໃຊ້ເພື່ອເພີ່ມພະນັກງານຖ້າພະນັກງານ. ໃນກໍລະນີທີສອງເມື່ອ '## n' ຖືກ ນຳ ໃຊ້, ມັນຈະເຮັດໃຫ້ຊື່ພະນັກງານເຂົ້າໄປໃນ 'ເງິນເດືອນ'. ເມື່ອສິ່ງນີ້ຖືກ ນຳ ໃຊ້ໃນ ຄຳ ຖະແຫຼງການ printf ມັນຈະສົ່ງຄືນຄ່າທີ່ເປັນຕົວແທນໂດຍຕົວແປ - ເງິນເດືອນ 100, ເງິນເດືອນ 200, ເງິນເດືອນ 300 ແລະອື່ນໆ

ນິຍາມ ()

ນີ້ແມ່ນຜູ້ປະຕິບັດການທີ່ໃຊ້ໃນການກວດສອບວ່າມະຫາພາກຖືກ ກຳ ນົດແລ້ວ. ຖ້າຖືກ ກຳ ນົດ, ມັນຈະສົ່ງຄືນຄ່າ TRUE ຫຼືຄ່າທີ່ບໍ່ແມ່ນສູນ. ຖ້າມັນບໍ່ໄດ້ຖືກ ກຳ ນົດ, ມັນຈະກັບຄືນ FALSE ຫລືສູນ. ຜູ້ປະຕິບັດການນີ້ມັກຈະຖືກນໍາໃຊ້ໃນເງື່ອນໄຂ #if.

#include <stdio.h>
#if !defined (SAL_INCREMENT) // verifies if the macro SAL_INCREMENT is already defined
	#define SAL_INCREMENT 0.1 //if not defined, set the value
#endif

void main(){
	int intSal = 10000;

	printf("Salary before Increment = %d\n", intSal);
	printf("Incremented Salary = %f", intSal + (intSal *SAL_INCREMENT));// increments the salary
}

Summary

ປະເພດທີ່ແຕກຕ່າງກັນຂອງ ຄຳ ແນະ ນຳ ກ່ຽວກັບຜູ້ ອຳ ນວຍການແມ່ນ:

syntaxes ຄຳ ສັ່ງແນະ ນຳ ທີ່ແຕກຕ່າງກັນແມ່ນ: