ะ ะตัˆะตะฝะพ: ะฒะทะตะผะตั‚ะต pid c

ะกะธะณัƒั€ะตะฝ! ะ•ั‚ะพ ะธัะบะฐะฝะฐั‚ะฐ ะพั‚ ะฒะฐั ัั‚ะฐั‚ะธั:

ะ ะฐะทะฑะธั€ะฐะฝะตั‚ะพ ะฝะฐ ัะปะพะถะฝะพัั‚ั‚ะฐ ะฝะฐ ะธะดะตะฝั‚ะธั„ะธะบะฐั†ะธัั‚ะฐ ะฝะฐ ะฟั€ะพั†ะตัะฐ ะต ะทะฐะดัŠะปะถะธั‚ะตะปะตะฝ ะฐัะฟะตะบั‚ ะฝะฐ ั‚ะตะปะตะผะตั‚ั€ะธั‡ะฝะธั ะผะพะฝะธั‚ะพั€ะธะฝะณ ะฟั€ะธ ะฟั€ะพะตะบั‚ะธั€ะฐะฝะตั‚ะพ ะฝะฐ ัะธัั‚ะตะผะฐั‚ะฐ. ะ˜ะดะตะฝั‚ะธั„ะธะบะฐั‚ะพั€ัŠั‚ ะฝะฐ ะฟั€ะพั†ะตัะฐ (PID) ะต ัƒะฝะธะบะฐะปะตะฝ ะฝะพะผะตั€, ะบะพะนั‚ะพ ัะต ะฟั€ะธัะฒะพัะฒะฐ ะฝะฐ ะฒัะตะบะธ ะฟั€ะพั†ะตั, ะบะพะณะฐั‚ะพ ั‚ะพะน ัั‚ะฐั€ั‚ะธั€ะฐ ะฝะฐ Unix-ะฟะพะดะพะฑะฝะธ ัะธัั‚ะตะผะธ ะบะฐั‚ะพ ั‚ะตะทะธ, ะธะทะณั€ะฐะดะตะฝะธ ะฝะฐ ะตะทะธะบ C.

ะ•ะดะฝะฐ ะพั‚ ั„ัƒะฝะบั†ะธะธั‚ะต, ะธะทะฟะพะปะทะฒะฐะฝะธ ะทะฐ ะธะทะฒะปะธั‡ะฐะฝะต ะฝะฐ PID, ะต ั„ัƒะฝะบั†ะธัั‚ะฐ getpid. ะกะธะฝั‚ะฐะบัะธััŠั‚ ะต ะดะพัั‚ะฐ ะฟั€ะพัั‚, ั‚ัŠะน ะบะฐั‚ะพ ะฝะต ะธะทะธัะบะฒะฐ ะฝะธะบะฐะบะฒะธ ะฟะฐั€ะฐะผะตั‚ั€ะธ ะธ ะฝะฐ ัะฒะพะน ั€ะตะด ะฟั€ะพัั‚ะพ ะฒั€ัŠั‰ะฐ ั†ัะปะพ ั‡ะธัะปะพ, ะฟั€ะตะดัั‚ะฐะฒะปัะฒะฐั‰ะพ PID ะฝะฐ ั‚ะตะบัƒั‰ะธั ะฟั€ะพั†ะตั. ะกะตะณะฐ ะฝะตะบะฐ ัะต ะฟะพั‚ะพะฟะธะผ ะดัŠะปะฑะพะบะพ ะฒ ั‚ะพะฒะฐ ะบะฐะบ ะผะพะถะตะผ ะฟั€ะพะณั€ะฐะผะฝะพ ะดะฐ ะฟะพะปัƒั‡ะธะผ PID ะฒ C.

    #include <stdio.h>
    #include <unistd.h>

    int main() {
        printf("The process ID is %dn", getpid());
        return 0;
    }

ะกะปะตะด ะบะฐั‚ะพ ะฒะบะปัŽั‡ะธั…ะผะต ะฝะตะพะฑั…ะพะดะธะผะธั‚ะต ะฑะธะฑะปะธะพั‚ะตะบะธ, ะดะตั„ะธะฝะธั€ะฐั…ะผะต ะพัะฝะพะฒะฝะฐั‚ะฐ ั„ัƒะฝะบั†ะธั. ะ’ ะพัะฝะพะฒะฝะฐั‚ะฐ ั„ัƒะฝะบั†ะธั ะธะผะฐะผะต ะฟั€ะพัั‚ะฐ ะบะพะผะฐะฝะดะฐ printf, ะบะพัั‚ะพ ะธะทะฒะตะถะดะฐ โ€žID ะฝะฐ ะฟั€ะพั†ะตัะฐ ะตโ€œ, ะฟะพัะปะตะดะฒะฐะฝะพ ะพั‚ ะดะตะนัั‚ะฒะธั‚ะตะปะฝะธั PID, ะบะพะนั‚ะพ ัะต ะธะทะฒะปะธั‡ะฐ ั‡ั€ะตะท ั„ัƒะฝะบั†ะธัั‚ะฐ getpid.

ะ—ะฝะฐั‡ะตะฝะธะต ะฝะฐ ะธะดะตะฝั‚ะธั„ะธะบะฐั†ะธัั‚ะฐ ะฝะฐ ะฟั€ะพั†ะตัะฐ

ะ˜ะดะตะฝั‚ะธั„ะธะบะฐั†ะธัั‚ะฐ ะฝะฐ ะฟั€ะพั†ะตัะฐ ะต ะพั‚ ั€ะตัˆะฐะฒะฐั‰ะพ ะทะฝะฐั‡ะตะฝะธะต, ั‚ัŠะน ะบะฐั‚ะพ ะฟะพะทะฒะพะปัะฒะฐ ะตั„ะตะบั‚ะธะฒะฝะฐ ะธ ัะธะณัƒั€ะฝะฐ ะบะพะผัƒะฝะธะบะฐั†ะธั ะผะตะถะดัƒ ั€ะฐะทะปะธั‡ะฝะธั‚ะต ะฟั€ะพั†ะตัะธ ะฒ ัะธัั‚ะตะผะฐั‚ะฐ. ะขะพะน ะณะฐั€ะฐะฝั‚ะธั€ะฐ, ั‡ะต ั€ะตััƒั€ัะธั‚ะต ัะฐ ะฟั€ะฐะฒะธะปะฝะพ ั€ะฐะทะฟั€ะตะดะตะปะตะฝะธ ะธ ัƒะฟั€ะฐะฒะปัะฒะฐะฝะธ ะผะตะถะดัƒ ั€ะฐะทะปะธั‡ะฝะธั‚ะต ะฟั€ะพั†ะตัะธ. ะ‘ะตะท PID, ัƒะฟั€ะฐะฒะปะตะฝะธะตั‚ะพ ะธ ะดะธั„ะตั€ะตะฝั†ะธั€ะฐะฝะตั‚ะพ ะฝะฐ ัะธัั‚ะตะผะฝะธั‚ะต ะฟั€ะพั†ะตัะธ ะฑะธ ะฑะธะปะพ ะธะทะบะปัŽั‡ะธั‚ะตะปะฝะพ ะฟั€ะตะดะธะทะฒะธะบะฐั‚ะตะปะฝะฐ, ะฐะบะพ ะฝะต ะธ ะฝะตะฒัŠะทะผะพะถะฝะฐ ะทะฐะดะฐั‡ะฐ.

ะ˜ะทะฟะพะปะทะฒะฐะฝะธ ะฑะธะฑะปะธะพั‚ะตะบะธ

ะ’ ะฝะฐัˆะธั ะบะพะด ัะผะต ะธะทะฟะพะปะทะฒะฐะปะธ ะดะฒะต ะถะธะทะฝะตะฝะพะฒะฐะถะฝะธ ะฑะธะฑะปะธะพั‚ะตะบะธ, ะทะฐ ะดะฐ ะฟะพะปัƒั‡ะธะผ PID:

  • stdio.h: ะขะพะฒะฐ ะต ะทะฐะณะปะฐะฒะตะฝ ั„ะฐะนะป, ะบะพะนั‚ะพ ะพะฑะธะบะฝะพะฒะตะฝะพ ััŠะดัŠั€ะถะฐ ะดะตะบะปะฐั€ะฐั†ะธั ะฝะฐ ะฝะฐะฑะพั€ ะพั‚ ั„ัƒะฝะบั†ะธะธ, ะฒะบะปัŽั‡ะฒะฐั‰ะธ ะทะฐะดะฐั‡ะธ ะทะฐ ะฒั…ะพะด/ะธะทั…ะพะด.
  • unistd.h: ะžะทะฝะฐั‡ะฐะฒะฐ ัั‚ะฐะฝะดะฐั€ั‚ะฝะฐั‚ะฐ ะฑะธะฑะปะธะพั‚ะตะบะฐ ะฝะฐ Unix, ััŠะดัŠั€ะถะฐ ะฝะตะพะฑั…ะพะดะธะผะธั‚ะต ะดะตั„ะธะฝะธั†ะธะธ ะธ ะดะตะบะปะฐั€ะฐั†ะธะธ ะทะฐ ะธะทะฒัŠั€ัˆะฒะฐะฝะต ะฝะฐ ัะธัั‚ะตะผะฝะธ ะธะทะฒะธะบะฒะฐะฝะธั.

ะ—ะฐ ะดะฐ ะทะฐะดัŠะปะฑะพั‡ะธะผ ะฝะฐัˆะตั‚ะพ ั€ะฐะทะฑะธั€ะฐะฝะต, ะฝะต ะทะฐะฑั€ะฐะฒัะนั‚ะต, ั‡ะต ะฑะธะฑะปะธะพั‚ะตะบะธั‚ะต ะฟั€ะตะดะพัั‚ะฐะฒัั‚ ะฟั€ะตะดะฒะฐั€ะธั‚ะตะปะฝะพ ะบะพะผะฟะธะปะธั€ะฐะฝ ะบะพะด, ะบะพะนั‚ะพ ะผะพะถะต ะดะฐ ัะต ะธะทะฟะพะปะทะฒะฐ ะฟะพะฒั‚ะพั€ะฝะพ, ัะฟะตัั‚ัะฒะฐะนะบะธ ะฝะฐ ั€ะฐะทั€ะฐะฑะพั‚ั‡ะธั†ะธั‚ะต ะฟะพะฒั‚ะพั€ะฝะพ ะฟะธัะฐะฝะต ะฝะฐ ัะปะพะถะฝะธ ะบะพะดะพะฒะต. ะะฐะฟั€ะธะผะตั€ stdio.h ะฝะธ ะฟะพะทะฒะพะปัะฒะฐ ะปะตัะตะฝ ะฝะฐั‡ะธะฝ ะทะฐ ะฒะทะฐะธะผะพะดะตะนัั‚ะฒะธะต ั ะฒั…ะพะดะฝะธ ะธะปะธ ะธะทั…ะพะดะฝะธ ัƒัั‚ั€ะพะนัั‚ะฒะฐ, ะดะพะบะฐั‚ะพ unistd.h ะฝะธ ะฟะพะผะฐะณะฐ ะดะฐ ะฟั€ะฐะฒะธะผ ัะธัั‚ะตะผะฝะธ ะธะทะฒะธะบะฒะฐะฝะธั, ะฑะตะท ะดะฐ ะทะฝะฐะตะผ ะฒัŠั‚ั€ะตัˆะฝะธั‚ะต ั‚ัŠะฝะบะพัั‚ะธ ะฝะฐ ัะธัั‚ะตะผะฐั‚ะฐ.

ะ’ะธะถั‚ะต ะฟะพะฒะตั‡ะต

ะ ะตัˆะตะฝะพ: ะฟั€ะพะธะทะฒะพะปะฝะพ ั‡ะธัะปะพ ะผะตะถะดัƒ 2 ะฒ C

ะ“ะตะฝะตั€ะธั€ะฐะฝะต ะฝะฐ ัะปัƒั‡ะฐะนะฝะธ ั‡ะธัะปะฐ ะผะตะถะดัƒ 2 ะฒ ะตะทะธะบะฐ ะทะฐ ะฟั€ะพะณั€ะฐะผะธั€ะฐะฝะต C

ะกะฟะพัะพะฑะฝะพัั‚ั‚ะฐ ะทะฐ ะณะตะฝะตั€ะธั€ะฐะฝะต ะฝะฐ ะฟั€ะพะธะทะฒะพะปะฝะธ ั‡ะธัะปะฐ ะผะพะถะต ะดะฐ ะฑัŠะดะต ะบั€ะธั‚ะธั‡ะฝะฐ ะฟั€ะธ ะพะฟั€ะตะดะตะปะตะฝะธ ั‚ะธะฟะพะฒะต ะทะฐะดะฐั‡ะธ ะทะฐ ะบะพะผะฟัŽั‚ัŠั€ะฝะพ ะฟั€ะพะณั€ะฐะผะธั€ะฐะฝะต, ะพัะพะฑะตะฝะพ ะฟั€ะธ ะฟั€ะพะตะบั‚ะธั€ะฐะฝะต ะฝะฐ ะฐะปะณะพั€ะธั‚ัŠะผ ะธะปะธ ะบัŠะดะตั‚ะพ ัะต ะธะทะธัะบะฒะฐ ัะธะผัƒะปะฐั†ะธั. ะ’ ั‚ะฐะทะธ ัั‚ะฐั‚ะธั ั‰ะต ัะต ะทะฐะดัŠะปะฑะพั‡ะธะผ ะฒ ะพัะฝะพะฒะตะฝ ะฐัะฟะตะบั‚ ะฝะฐ ะฟั€ะพะณั€ะฐะผะธั€ะฐะฝะตั‚ะพ ะฝะฐ C, ะบะพะนั‚ะพ ะต ะณะตะฝะตั€ะธั€ะฐะฝะตั‚ะพ ะฝะฐ ะฟั€ะพะธะทะฒะพะปะฝะธ ั‡ะธัะปะฐ. ะฉะต ะฟั€ะธะตะผะตะผ, ั‡ะต ะธะผะฐั‚ะต ะพัะฝะพะฒะฝะธ ะฟะพะทะฝะฐะฝะธั ะทะฐ ะตะทะธะบะฐ ะทะฐ ะฟั€ะพะณั€ะฐะผะธั€ะฐะฝะต C. C ะต ะผะพั‰ะตะฝ ะตะทะธะบ ั ะพะฑั‰ะพ ะฟั€ะตะดะฝะฐะทะฝะฐั‡ะตะฝะธะต ะบะพะตั‚ะพ ะดะฐะฒะฐ ะฝะฐ ะฟั€ะพะณั€ะฐะผะธัั‚ะธั‚ะต ะฟะพะฒะตั‡ะต ะบะพะฝั‚ั€ะพะป ะธ ะตั„ะตะบั‚ะธะฒะฝะพัั‚, ะบะฐั‚ะพ ะต ะพั‚ะปะธั‡ะตะฝ ะทะฐ ะฟั€ะพะณั€ะฐะผะธั€ะฐะฝะต ะฝะฐ ะฝะธัะบะพ ะฝะธะฒะพ

ะ’ะธะถั‚ะต ะฟะพะฒะตั‡ะต

ะ ะตัˆะตะฝะพ: ะฟะตั‡ะฐั‚ ะฒ ั€ะพะทะพะฒะพ ะฒ c

ะ ะฐะทะฑะธั€ะฐ ัะต, ะดะฐ ะทะฐะฟะพั‡ะฒะฐะผะต!

ะŸะตั‡ะฐั‚ ะฒ ั€ะพะทะพะฒะพ ะต ะพะฟะตั€ะฐั‚ะพั€ ะทะฐ ะฟะตั‡ะฐั‚, ะพั†ะฒะตั‚ะตะฝ ะฒ ั€ะพะทะพะฒะพ ั‚ะตะบัั‚ะพะฒ ะธะทั…ะพะด ะฒ C ะฟั€ะพะณั€ะฐะผะธั€ะฐะฝะต. ะขะฐะทะธ ะทะฐะดะฐั‡ะฐ ะทะฐ ะฟั€ะพะณั€ะฐะผะธั€ะฐะฝะต ะฝะต ะต ั‡ะตัั‚ะพ ัั€ะตั‰ะฐะฝะฐ, ะฝะพ ะต ะดะพัั‚ะฐ ะธะฝั‚ะตั€ะตัะฝะฐ ะธ ะดะตะผะพะฝัั‚ั€ะธั€ะฐ ะณัŠะฒะบะฐะฒะพัั‚ั‚ะฐ ะธ ะณัŠะฒะบะฐะฒะพัั‚ั‚ะฐ ะฝะฐ C. ะ—ะฐะดะฐั‡ะฐั‚ะฐ ะต ัƒะฝะธะบะฐะปะฝะฐ, ะฝะพ ะฒะธ ะฟะพะทะฒะพะปัะฒะฐ ะดะฐ ั€ะฐะทะฑะตั€ะตั‚ะต ะบะฐะบ ั‚ั€ัะฑะฒะฐ ะดะฐ ะผะฐะฝะธะฟัƒะปะธั€ะฐั‚ะต ะบะพะฝั„ะธะณัƒั€ะฐั†ะธะธั‚ะต ะฝะฐ ะดะธัะฟะปะตั ะฝะฐ ั‚ะตั€ะผะธะฝะฐะปะฐ, ะทะฐ ะดะฐ ั ะฟะพัั‚ะธะณะฝะตั‚ะต.

ะ’ะธะถั‚ะต ะฟะพะฒะตั‡ะต

ะ ะตัˆะตะฝะพ: ั„ะพั€ะผัƒะปะฐ ะพั‚ ะคะฐั€ะตะฝั…ะฐะนั‚ ะดะพ ะฆะตะปะทะธะน

ะขัŠั€ัะธั‚ะต ะดะฐ ะบะพะฝะฒะตั€ั‚ะธั€ะฐั‚ะต ะคะฐั€ะตะฝั…ะฐะนั‚ ะฒ ะฆะตะปะทะธะน? ะะฐัˆะฐั‚ะฐ ะปะตัะฝะฐ ั„ะพั€ะผัƒะปะฐ ั‰ะต ะฒะธ ะฟะพะผะพะณะฝะต!

ะ ะตัˆะตะฝะพ: ะฟั€ะธะผะตั€ c va_list

ะ’ ะฟั€ะพะณั€ะฐะผะธั€ะฐะฝะตั‚ะพ ะฝะฐ C ั€ะฐะฑะพั‚ะฐั‚ะฐ ั ั„ัƒะฝะบั†ะธะธ ั ะฟั€ะพะผะตะฝะปะธะฒะธ ะฐั€ะณัƒะผะตะฝั‚ะธ ะต ะพั‚ ั€ะตัˆะฐะฒะฐั‰ะพ ะทะฝะฐั‡ะตะฝะธะต. ะŸั€ะตะดัั‚ะฐะฒะตั‚ะต ัะธ ะฟั€ะธะปะฐะณะฐะฝะต ะฝะฐ ั„ัƒะฝะบั†ะธั, ะบะพัั‚ะพ ะฟั€ะธะตะผะฐ ะฟั€ะพะผะตะฝะปะธะฒ ะฑั€ะพะน ะฐั€ะณัƒะผะตะฝั‚ะธ. ะขะพะฒะฐ ะฝัะผะฐ ะปะธ ะดะฐ ะพะทะฝะฐั‡ะฐะฒะฐ, ั‡ะต ะฒะฐัˆะธัั‚ ะบะพะด ัะต ะฐะดะฐะฟั‚ะธั€ะฐ ะบัŠะผ ะฝัƒะถะดะธั‚ะต ะฝะฐ ะฟั€ะธะปะพะถะตะฝะธะตั‚ะพ, ะบะฐั‚ะพ ะฟะพ ั‚ะพะทะธ ะฝะฐั‡ะธะฝ ะฟะพะดะพะฑั€ัะฒะฐ ะฝะตะณะพะฒะฐั‚ะฐ ะณัŠะฒะบะฐะฒะพัั‚ ะธ ะฟั€ะพะธะทะฒะพะดะธั‚ะตะปะฝะพัั‚? ะ”ะฝะตั ั‰ะต ัะต ะฟะพั‚ะพะฟะธะผ ะฒ ะตะดะฝะฐ ั‚ะฐะบะฐะฒะฐ ั„ะฐะฝั‚ะฐัั‚ะธั‡ะฝะฐ ั„ัƒะฝะบั†ะธั, ะฟั€ะตะดะปะฐะณะฐะฝะฐ ะพั‚ ะตะทะธะบะฐ ะทะฐ ะฟั€ะพะณั€ะฐะผะธั€ะฐะฝะต C โ€“ va_list โ€“ ะฒัŠะฒ ั„ัƒะฝะบั†ะธั ะฒ ั€ะฐะผะบะธั‚ะต ะฝะฐ ะฑะธะฑะปะธะพั‚ะตะบะฐั‚ะฐ stdarg.h, ะธะทะฟะพะปะทะฒะฐะฝะฐ ะทะฐ ะพะฑั€ะฐะฑะพั‚ะบะฐ ะฝะฐ ั‚ะฐะบะธะฒะฐ ั„ัƒะฝะบั†ะธะธ.

ะ’ะธะถั‚ะต ะฟะพะฒะตั‡ะต

ะ ะตัˆะตะฝะพ: myFgets ะฒ c

ะ ะฐะทะฑะธั€ะฐ ัะต, ะฝะตะบะฐ ะทะฐะฟะพั‡ะฝะตะผ ััŠั ัั‚ะฐั‚ะธัั‚ะฐ:

myFgets ะต ะตะดะฝะฐ ะพั‚ ะพัะฝะพะฒะฝะธั‚ะต ั„ัƒะฝะบั†ะธะธ ะฒ C ะทะฐ ะฟะพะปัƒั‡ะฐะฒะฐะฝะต ะฝะฐ ะธะฝั„ะพั€ะผะฐั†ะธั ะพั‚ ะฟะพั‚ั€ะตะฑะธั‚ะตะปั. ะขะพะน ะต ั‡ะฐัั‚ ะพั‚ ะฑะธะฑะปะธะพั‚ะตะบะฐั‚ะฐ stdio ะธ ัะต ะพั‚ะบั€ะพัะฒะฐ ะบะฐั‚ะพ ะฟะพ-ะฑะตะทะพะฟะฐัะฝะฐ ะฐะปั‚ะตั€ะฝะฐั‚ะธะฒะฐ ะฝะฐ ะดั€ัƒะณะธั‚ะต ัะธ ะบะพะปะตะณะธ ะบะฐั‚ะพ scanf, ะฟะพั€ะฐะดะธ ัะฟะพัะพะฑะฝะพัั‚ั‚ะฐ ัะธ ะดะฐ ะฟั€ะตะดะพั‚ะฒั€ะฐั‚ัะฒะฐ ะฟั€ะตะฟัŠะปะฒะฐะฝะตั‚ะพ ะฝะฐ ะฑัƒั„ะตั€ะฐ.

#include <stdio.h>

#define SIZE 100

int main()
{
    char str[SIZE];

    printf("Enter a string: ");
    if(fgets(str, SIZE, stdin) != NULL)
    {
        printf("You entered: ");
        puts(str);
    }

    return 0;
}

ะกะปะตะด ะบะฐั‚ะพ ะทะฐะฟะพั‡ะฝะฐ ั ะบั€ะฐั‚ะบะพ ะฒัŠะฒะตะดะตะฝะธะต ะทะฐ myFgets, ะฟั€ะตะดะพัั‚ะฐะฒะตะฝะธัั‚ C ะบะพะด ะฟะพ-ะณะพั€ะต ะธะทะฟะพะปะทะฒะฐ ั„ัƒะฝะบั†ะธัั‚ะฐ myFgets ะทะฐ ะฟะพะปัƒั‡ะฐะฒะฐะฝะต ะฝะฐ ะฒั…ะพะดะตะฝ ะฝะธะท ะพั‚ ะฟะพั‚ั€ะตะฑะธั‚ะตะปั.

ะšะฐะบ ั€ะฐะฑะพั‚ะธ myFgets?

ะคัƒะฝะบั†ะธัั‚ะฐ ะฝะฐ fgets ะต ะดะฐ ั‡ะตั‚ะต ะฝะธะท ะพั‚ ัั‚ะฐะฝะดะฐั€ั‚ะฝะธั ะฒั…ะพะด (stdin), ะพะฑะธะบะฝะพะฒะตะฝะพ ะพั‚ ะบะปะฐะฒะธะฐั‚ัƒั€ะฐั‚ะฐ. ะคัƒะฝะบั†ะธัั‚ะฐ fgets ะฝะต ัะต ั€ะฐะทะปะธั‡ะฐะฒะฐ ะพั‚ ะดั€ัƒะณะธั‚ะต ะฒั…ะพะดะฝะธ ั„ัƒะฝะบั†ะธะธ ะฒ C ะฒ ะธะทะธัะบะฒะฐะฝะตั‚ะพ ัะธ ะทะฐ ั‚ั€ะธ ะฟะฐั€ะฐะผะตั‚ัŠั€ะฐ: ะฑัƒั„ะตั€ ะทะฐ ั‡ะตั‚ะตะฝะต ะฝะฐ ะฒั…ะพะดะฐ, ะผะฐะบัะธะผะฐะปะตะฝ ั€ะฐะทะผะตั€ ะฝะฐ ะฑัƒั„ะตั€ะฐ ะธ ะฒั…ะพะดะตะฝ ะฟะพั‚ะพะบ, ะพั‚ ะบะพะนั‚ะพ ะดะฐ ัะต ั‡ะตั‚ะต. ะŸะพ-ะบะพะฝะบั€ะตั‚ะฝะพ, ัะปะตะด ะฟั€ะพั‡ะธั‚ะฐะฝะต ะฝะฐ ะฝะธะทะฐ, fgets ะดะพะฑะฐะฒั ะฝัƒะปะตะฒ ะทะฝะฐะบ ('') ะบัŠะผ ะบั€ะฐั.

ะ ะฐะทะฑะธั€ะฐะฝะต ะฝะฐ ะบะพะดะฐ ะฟะพ-ะณะพั€ะต

ะคัƒะฝะบั†ะธัั‚ะฐ, ะดะตั„ะธะฝะธั€ะฐะฝะฐ ะฟะพ-ะณะพั€ะต, ะทะฐะฟะพั‡ะฒะฐ ั ะดะตะบะปะฐั€ะธั€ะฐะฝะต ะฝะฐ ะฝะธะท (ะผะฐัะธะฒ) ั ะพะฟั€ะตะดะตะปะตะฝ ั€ะฐะทะผะตั€ (SIZE). ะกะปะตะด ั‚ะพะฒะฐ ะฟะพะดะบะฐะฝะฒะฐ ะฟะพั‚ั€ะตะฑะธั‚ะตะปั ะดะฐ ะฒัŠะฒะตะดะต ะฝะธะท. ะŸั€ะธ ะฒัŠะฒะตะถะดะฐะฝะต ะพั‚ ะฟะพั‚ั€ะตะฑะธั‚ะตะปั ัƒัะปะพะฒะฝะธัั‚ ะพะฟะตั€ะฐั‚ะพั€ ะฟั€ะพะฒะตั€ัะฒะฐ ะดะฐะปะธ ั„ัƒะฝะบั†ะธัั‚ะฐ fgets ะต ัƒัะฟัะปะฐ ะดะฐ ะฟั€ะพั‡ะตั‚ะต ะฝะธะทะฐ. ะะบะพ ะต ัƒัะฟัะป, ั‚ะพะน ะฟั€ะพะดัŠะปะถะฐะฒะฐ ะดะฐ ะพั‚ะฟะตั‡ะฐั‚ะฒะฐ ััŠั‰ะธั ะฝะธะท ะพะฑั€ะฐั‚ะฝะพ ะฝะฐ ะตะบั€ะฐะฝะฐ ั ะฟะพะผะพั‰ั‚ะฐ ะฝะฐ ั„ัƒะฝะบั†ะธัั‚ะฐ puts.

ะŸั€ะธ ั€ะฐะทะฑะธั€ะฐะฝะตั‚ะพ ะฝะฐ ะฒั€ัŠะทะบะฐั‚ะฐ ะผะตะถะดัƒ fgets, ั€ะฐะทะผะตั€ะฐ ะฝะฐ ะฑัƒั„ะตั€ะฐ ะธ ะฟั€ะตะดะพั‚ะฒั€ะฐั‚ัะฒะฐะฝะตั‚ะพ ะฝะฐ ะฟั€ะตะฟัŠะปะฒะฐะฝะตั‚ะพ ะฝะฐ ะฑัƒั„ะตั€ะฐ ะต ะฒะฐะถะฝะพ ะดะฐ ัะต ะฟั€ะธะทะฝะฐะต, ั‡ะต ะฑั€ะพัั‚ ะฝะฐ ัะธะผะฒะพะปะธั‚ะต, ะฟั€ะพั‡ะตั‚ะตะฝะธ ะพั‚ fgets, ะต ั ะตะดะธะฝ ะฟะพ-ะผะฐะปัŠะบ ะพั‚ ะฟะพัะพั‡ะตะฝะธั SIZE. ะขะพะฒะฐ ัะต ะฟั€ะฐะฒะธ, ะทะฐ ะดะฐ ัะต ะฟั€ะธัะฟะพัะพะฑะธ ะฝัƒะปะตะฒะธัั‚ ะทะฝะฐะบ ะฒ ะบั€ะฐั ะฝะฐ ะฒั…ะพะดะฐ.

ะกัŠะพั‚ะฒะตั‚ะฝะธ ะฑะธะฑะปะธะพั‚ะตะบะธ ะธ ั„ัƒะฝะบั†ะธะธ

ะŸะพ ะพั‚ะฝะพัˆะตะฝะธะต ะฝะฐ ะฑะธะฑะปะธะพั‚ะตะบะธั‚ะต, stdio.h ะต ะตะดะฝะฐ ะพั‚ ะฝะฐะน-ะพัะฝะพะฒะฝะธั‚ะต ะฑะธะฑะปะธะพั‚ะตะบะธ ะฒ C, ะธะทะฟะพะปะทะฒะฐะฝะฐ ะทะฐ ะพะฟะตั€ะฐั†ะธะธ ะทะฐ ะฒั…ะพะด/ะธะทั…ะพะด. ะะฐั‡ะธะฝัŠั‚ ะฝะฐ ะธะทะฟะพะปะทะฒะฐะฝะต ะต ั‚ะพะปะบะพะฒะฐ ะฟั€ะพัั‚, ะบะพะปะบะพั‚ะพ ะฒะบะปัŽั‡ะฒะฐะฝะตั‚ะพ ะผัƒ ะฒ ะฝะฐั‡ะฐะปะพั‚ะพ ะฝะฐ C ะบะพะดะฐ ั ะฟะพะผะพั‰ั‚ะฐ ะฝะฐ ะดะธั€ะตะบั‚ะธะฒะฐั‚ะฐ #include.

ะŸะพ ะพั‚ะฝะพัˆะตะฝะธะต ะฝะฐ ั„ัƒะฝะบั†ะธะธั‚ะต, ะธะทะฟะพะปะทะฒะฐะฝะธ ะฒ ั‚ะพะทะธ ะบะพะด, fgets ะฟั€ะธะฝะฐะดะปะตะถะธ ะบัŠะผ ั‚ะฐะทะธ ะฑะธะฑะปะธะพั‚ะตะบะฐ, ะทะฐะตะดะฝะพ ั puts ะธ printf. ะ”ะพะบะฐั‚ะพ fgets ะฟั€ะพัƒั‡ะฒะฐ, puts ัะต ะธะทะฟะพะปะทะฒะฐ ะทะฐ ะทะฐะฟะธั ะฝะฐ ะฝะธะท ะบัŠะผ stdout ะดะพ, ะฝะพ ะฑะตะท ะดะฐ ะฒะบะปัŽั‡ะฒะฐ ะฝัƒะปะตะฒะธั ะทะฝะฐะบ. ะคัƒะฝะบั†ะธัั‚ะฐ printf ั„ะพั€ะผะธั€ะฐ ะฝะธะท ะพั‚ ะดะฐะฝะฝะธ ะทะฐ ะธะทั…ะพะด ะฒัŠะท ะพัะฝะพะฒะฐ ะฝะฐ ั„ะพั€ะผะฐั‚ะธั€ะฐั‰ ะฝะธะท ะธ ะฐั€ะณัƒะผะตะฝั‚ะธ.

ะœะพะปั, ะธะผะฐะนั‚ะต ะฟั€ะตะดะฒะธะด, ั‡ะต ะทะฐ ะฑะตะทะพะฟะฐัะตะฝ ะธ ะตั„ะตะบั‚ะธะฒะตะฝ ะฟะพะดั…ะพะด ะบัŠะผ ะฒัŠะฒะตะถะดะฐะฝะต ะฝะฐ ะฝะธะท ะพั‚ ะฟะพั‚ั€ะตะฑะธั‚ะตะปั myFgets ะธะผะฐ ะดะพะบะฐะทะฐะฝ ะพะฟะธั‚ ะฒ ัั„ะตั€ะฐั‚ะฐ ะฝะฐ ะฟั€ะพะณั€ะฐะผะธั€ะฐะฝะตั‚ะพ ะฝะฐ C, ะบะฐั‚ะพ ะพะณั€ะฐะฝะธั‡ะฐะฒะฐ ั€ะฐะทะผะตั€ะฐ ะฝะฐ ะฒั…ะพะดะฐ ะธ ะฟะพ ั‚ะพะทะธ ะฝะฐั‡ะธะฝ ะฟั€ะตะดะพั‚ะฒั€ะฐั‚ัะฒะฐ ะฟะพั‚ะตะฝั†ะธะฐะปะฝะพ ะฟั€ะตะฟัŠะปะฒะฐะฝะต ะฝะฐ ะฑัƒั„ะตั€ะฐ.

ะ’ะธะถั‚ะต ะฟะพะฒะตั‡ะต

ะ ะตัˆะตะฝะพ: buble sort c

ะ ะฐะทะฑะธั€ะฐ ัะต, ะผะพะณะฐ ะดะฐ ัะต ัะฟั€ะฐะฒั ั ั‚ะฐะทะธ ะทะฐะดะฐั‡ะฐ! ะ•ั‚ะพ ะบะฐะบ ะฑะธั… ะทะฐะฟะพั‡ะฝะฐะป ัั‚ะฐั‚ะธัั‚ะฐ:

ะะปะณะพั€ะธั‚ะผะธั‚ะต ะทะฐ ัะพั€ั‚ะธั€ะฐะฝะต ัะฐ ะฒะฐะถะฝะฐ ั‡ะฐัั‚ ะพั‚ ะบะพะผะฟัŽั‚ัŠั€ะฝะธั‚ะต ะฝะฐัƒะบะธ ะธ ะฟั€ะพะณั€ะฐะผะธั€ะฐะฝะตั‚ะพ, ะทะฐั‰ะพั‚ะพ ะฝะธ ะฟะพะทะฒะพะปัะฒะฐั‚ ะตั„ะตะบั‚ะธะฒะฝะพ ะดะฐ ะฟะพะดั€ะตะถะดะฐะผะต ะดะฐะฝะฝะธ. ะ•ะดะฝะฐ ะพั‚ ะฝะฐะน-ะฟั€ะพัั‚ะธั‚ะต ะธ ะธะฝั‚ัƒะธั‚ะธะฒะฝะธ ั‚ะตั…ะฝะธะบะธ ะทะฐ ัะพั€ั‚ะธั€ะฐะฝะต ะต Bubble Sort, ะฐะปะณะพั€ะธั‚ัŠะผ, ะฑะฐะทะธั€ะฐะฝ ะฝะฐ ัั€ะฐะฒะฝะตะฝะธะต, ะบะพะนั‚ะพ ะผะฝะพะณะพะบั€ะฐั‚ะฝะพ ะฟั€ะตะผะธะฝะฐะฒะฐ ะฟั€ะตะท ัะฟะธััŠะบะฐ, ัั€ะฐะฒะฝัะฒะฐ ััŠัะตะดะฝะธ ะตะปะตะผะตะฝั‚ะธ ะธ ะณะธ ั€ะฐะทะผะตะฝั, ะฐะบะพ ัะฐ ะฒ ะณั€ะตัˆะตะฝ ั€ะตะด. ะŸั€ะตะผะธะฝะฐะฒะฐะฝะตั‚ะพ ะฟั€ะตะท ะผะฐัะธะฒะฐ ัะต ะธะทะฒัŠั€ัˆะฒะฐ ะธั‚ะตั€ะฐั‚ะธะฒะฝะพ, ะดะพะบะฐั‚ะพ ะฝะต ัะฐ ะฝะตะพะฑั…ะพะดะธะผะธ ััƒะฐะฟะพะฒะต, ะบะพะตั‚ะพ ะฟะพะบะฐะทะฒะฐ, ั‡ะต ัะฟะธััŠะบัŠั‚ ะต ัะพั€ั‚ะธั€ะฐะฝ.

Bubble Sort ะฝะต ะต ะตั„ะตะบั‚ะธะฒะตะฝ ะฐะปะณะพั€ะธั‚ัŠะผ ะทะฐ ัะพั€ั‚ะธั€ะฐะฝะต ะฝะฐ ะฟะพ-ะณะพะปะตะผะธ ัะฟะธััŠั†ะธ, ะฝะพ ะฟะพั€ะฐะดะธ ัะฒะพัั‚ะฐ ะฟั€ะพัั‚ะพั‚ะฐ ั‡ะตัั‚ะพ ัะต ะฟั€ะตะฟะพะดะฐะฒะฐ ะฒัŠะฒ ะฒัŠะฒะตะถะดะฐั‰ะธ ะบัƒั€ัะพะฒะต ะฟะพ ะบะพะผะฟัŽั‚ัŠั€ะฝะธ ะฝะฐัƒะบะธ. ะ’ัŠะฟั€ะตะบะธ ั‡ะต ะฝะตะณะพะฒะฐั‚ะฐ ัั€ะตะดะฝะฐ ะธ ะฝะฐะน-ะปะพัˆะฐั‚ะฐ ะฒั€ะตะผะตะฒะฐ ัะปะพะถะฝะพัั‚ ะพั‚ O (n ^ 2) ะผะพะถะต ะดะฐ ะณะพ ะฝะฐะฟั€ะฐะฒะธ ะปะพัˆ ะธะทะฑะพั€ ะทะฐ ะณะพะปะตะผะธ ะฝะฐะฑะพั€ะธ ะพั‚ ะดะฐะฝะฝะธ, ั‚ะพะน ะฒัะต ะพั‰ะต ะผะพะถะต ะดะฐ ะฑัŠะดะต ะฟั€ะฐะบั‚ะธั‡ะตะฝ ะฒ ะพะฟั€ะตะดะตะปะตะฝะธ ัะปัƒั‡ะฐะธ ะฝะฐ ัƒะฟะพั‚ั€ะตะฑะฐ, ะบัŠะดะตั‚ะพ ะฟั€ะพัั‚ะพั‚ะฐั‚ะฐ ะธ ะปะตะบะพั‚ะฐั‚ะฐ ะฝะฐ ะฒะฝะตะดั€ัะฒะฐะฝะต ัะฐ ะฟะพ-ะฒะฐะถะฝะธ ะพั‚ ััƒั€ะพะฒะฐั‚ะฐ ะฟั€ะพะธะทะฒะพะดะธั‚ะตะปะฝะพัั‚.

#include

void bubbleSort(int array[], int size) {
for (int step = 0; step < size - 1; ++step) { for (int i = 0; i < size - step - 1; ++i) { if (array[i] > array[i + 1) ]) {
int temp = ะผะฐัะธะฒ [i];
ะผะฐัะธะฒ[i] = ะผะฐัะธะฒ[i + 1];
ะผะฐัะธะฒ [i + 1] = ั‚ะตะผะฟ;
}
}
}
}

void printArray(int array[], int size) {
for (int i = 0; i < size; ++i) printf("%d ", array[i]); printf("n"); } int main() { int data[] = {-2, 45, 0, 11, -9}; int ั€ะฐะทะผะตั€ = sizeof(ะดะฐะฝะฝะธ) / sizeof(ะดะฐะฝะฝะธ[0]); bubbleSort(ะดะฐะฝะฝะธ, ั€ะฐะทะผะตั€); printf("ะกะพั€ั‚ะธั€ะฐะฝ ะผะฐัะธะฒ ะฒัŠะฒ ะฒัŠะทั…ะพะดัั‰ ั€ะตะด:n"); printArray(ะดะฐะฝะฝะธ, ั€ะฐะทะผะตั€); ะฒั€ัŠั‰ะฐะฝะต 0; } [/ะบะพะด]

ะ’ะธะถั‚ะต ะฟะพะฒะตั‡ะต

ะ ะตัˆะตะฝะพ: ัะพั€ั‚ะธั€ะฐะฝะต ะฝะฐ ัะตั€ะธะธ

ะšะพะณะฐั‚ะพ ะณะพะฒะพั€ะธะผ ะทะฐ ัะพั€ั‚ะธั€ะฐะฝะต ะฒ ะฟะฐั€ะฐะดะธะณะผะฐั‚ะฐ ะฝะฐ ะฟั€ะพะณั€ะฐะผะธั€ะฐะฝะตั‚ะพ, ั‚ะพ ัะต ัั‡ะธั‚ะฐ ะทะฐ ะตะดะฝะฐ ะพั‚ ะฝะฐะน-ะบั€ะธั‚ะธั‡ะฝะธั‚ะต ะพะฟะตั€ะฐั†ะธะธ ะธ ั‡ะตัั‚ะพ ัะต ะธะทะธัะบะฒะฐ ะฟั€ะธ ั€ะฐะทั€ะฐะฑะพั‚ะฒะฐะฝะตั‚ะพ ะฝะฐ ะฟั€ะธะปะพะถะตะฝะธั. ะ’ ะบะพะผะฟัŽั‚ัŠั€ะฝะธั‚ะต ะฝะฐัƒะบะธ ะฐะปะณะพั€ะธั‚ัŠะผัŠั‚ ะทะฐ ัะพั€ั‚ะธั€ะฐะฝะต ะต ะผะตั‚ะพะด, ะธะทะฟะพะปะทะฒะฐะฝ ะทะฐ ั€ะตะพั€ะณะฐะฝะธะทะธั€ะฐะฝะต ะฝะฐ ะตะปะตะผะตะฝั‚ะธั‚ะต ะฝะฐ ัะฟะธััŠะบ ะฒ ะพะฟั€ะตะดะตะปะตะฝ ั€ะตะด, ะฑะธะปะพ ั‚ะพ ั‡ะธัะปะพะฒะพ ะฒัŠะทั…ะพะดัั‰ ะธะปะธ ะฝะธะทั…ะพะดัั‰ ะธะปะธ ะปะตะบัะธะบะพะณั€ะฐั„ัะบะธ. ะ’ ั‚ะพะทะธ ัั†ะตะฝะฐั€ะธะน ะฝะธะต ั‰ะต ัะต ััŠัั€ะตะดะพั‚ะพั‡ะธะผ ะพัะฝะพะฒะฝะพ ะฒัŠั€ั…ัƒ ะฟั€ะพะฑะปะตะผะฐ ะทะฐ ัะพั€ั‚ะธั€ะฐะฝะต ะฝะฐ ัะตั€ะธะธั‚ะต ะฒ ะพะฑะปะฐัั‚ั‚ะฐ ะฝะฐ ะฟั€ะพะณั€ะฐะผะธั€ะฐะฝะตั‚ะพ ะฝะฐ C, ะฝะตะณะพะฒะฐั‚ะฐ ั€ะฐะฑะพั‚ะฐ ะธ ะบะฐะบ ะฟั€ะตะดะปะฐะณะฐ ะตั„ะตะบั‚ะธะฒะฝะธ ั€ะตัˆะตะฝะธั.

#include
void sort(int array[], int n) {
ะทะฐ (int ัั‚ัŠะฟะบะฐ = 0; ัั‚ัŠะฟะบะฐ < n - 1; ++ัั‚ัŠะฟะบะฐ) { int min_idx = ัั‚ัŠะฟะบะฐ; for (int i = ัั‚ัŠะฟะบะฐ + 1; i < n; ++i) { if (ะผะฐัะธะฒ [i] < ะผะฐัะธะฒ [min_idx]) { min_idx = i; } } int temp = array[min_idx]; ะผะฐัะธะฒ [min_idx] = ะผะฐัะธะฒ [ัั‚ัŠะฟะบะฐ]; ะผะฐัะธะฒ [ัั‚ัŠะฟะบะฐ] = ั‚ะตะผะฟ; } } [/ะบะพะด]

ะ’ะธะถั‚ะต ะฟะพะฒะตั‡ะต

ะ ะตัˆะตะฝะพ: ะบะฐะบ ะดะฐ ะฝะฐะฟะธัˆะฐ ั„ัƒะฝะบั†ะธั ะทะฐ ะพั‚ะฟะตั‡ะฐั‚ะฒะฐะฝะต ะฝะฐ ะฒััะบะฐ ะผะธะฝัƒั‚ะฐ ะพั‚ ะดะตะฝั ะฒ c

ะะฐะฟะธัะฒะฐะฝะตั‚ะพ ะฝะฐ ะฟั€ะธะปะพะถะตะฝะธะต ะฝะฐ C, ะบะพะตั‚ะพ ะพั‚ะฟะตั‡ะฐั‚ะฒะฐ ะฒััะบะฐ ะผะธะฝัƒั‚ะฐ ะพั‚ ะดะตะฝั, ะผะพะถะต ะดะฐ ะธะทะณะปะตะถะดะฐ ะบะฐั‚ะพ ะธะฝั‚ะตั€ะตัะฝะพ ะฟั€ะตะดะธะทะฒะธะบะฐั‚ะตะปัั‚ะฒะพ, ะพัะพะฑะตะฝะพ ะฐะบะพ ัั‚ะต ะฝะฐั‡ะธะฝะฐะตั‰ ะฒ ะฟั€ะพะณั€ะฐะผะธั€ะฐะฝะตั‚ะพ. ะ—ะฐ ั‰ะฐัั‚ะธะต ะตะทะธะบัŠั‚ ะทะฐ ะฟั€ะพะณั€ะฐะผะธั€ะฐะฝะต C ะฟั€ะตะดะปะฐะณะฐ ะผะฝะพะถะตัั‚ะฒะพ ะฑะธะฑะปะธะพั‚ะตะบะธ ะธ ั„ัƒะฝะบั†ะธะธ, ะบะพะธั‚ะพ ะผะพะถะตะผ ะดะฐ ะธะทะฟะพะปะทะฒะฐะผะต, ะทะฐ ะดะฐ ั€ะฐะทั€ะตัˆะธะผ ั‚ะพะทะธ ะฟั€ะพะฑะปะตะผ. ะŸั€ะตะดะธ ะดะฐ ัะต ะทะฐะดัŠะปะฑะพั‡ะธั‚ะต ะฒ ั€ะตัˆะตะฝะธะตั‚ะพ ะฝะฐ ะฟั€ะพะฑะปะตะผะฐ, ะฒะฐะถะฝะพ ะต ะดะฐ ั€ะฐะทะฑะตั€ะตั‚ะต ะบะฐะบะฒะพ ะฒะบะปัŽั‡ะฒะฐ ั‚ะฐะทะธ ะทะฐะดะฐั‡ะฐ. ะžัะฝะพะฒะฝะพ, ั†ะตะปั‚ะฐ ั‚ัƒะบ ะต ะดะฐ ะฝะฐะฟะธัˆะตะผ C ะฟั€ะพะณั€ะฐะผะฐ, ะบะพัั‚ะพ ั‰ะต ะพั‚ะฟะตั‡ะฐั‚ะฐ ะฒัะธั‡ะบะธ ะผะธะฝัƒั‚ะธ ะทะฐ ะตะดะธะฝ ะดะตะฝ, ะพั‚ 00:00 ะดะพ 23:59.

ะ’ะธะถั‚ะต ะฟะพะฒะตั‡ะต