ตัวชี้ (Pointer) ตัวชี้ (Pointer) มีลักษณะเด่นของเครื่องมือดำเนินการที่สำคัญที่สุดในภาษาซี ตัวชี้หรือพอยน์เตอร์ มีประโยชน์มากในการจัดการโครงสร้างข้อมูลแบบพลวัต (dynamic data structure) เช่น รายการเชื่อมโยง (Linked List) เป็นต้น ซึ่งรายละเอียดของเนื้อหาในส่วนนี้จะสามารถศึกษาได้ในวิชาโครงสร้างข้อมูล นอกจากนี้ตัวแปรชนิดตัวชี้ยังมีประโยชน์ในแง่ของประสิทธิภาพการทำงาน ช่วยให้โปรแกรมทำงานได้เร็วขึ้นและประหยัดเนื้อที่ในหน่วยจำ ซึ่งเนื้อหาในส่วนนี้จะแสดงในหัวข้อการใช้งานตัวชี้กับฟังก์ชัน 1. การประกาศตัวแปรชนิดตัวชี้ตัวแปรชนิดตัวชี้จะเก็บค่าเลขที่อยู่ของหน่วยความจำ ซึ่งแตกต่างจากตัวแปรชนิดอื่นที่จะเก็บค่าที่แท้จริง เช่นตัวแปรชนิดจำนวนจริง (float) จะเก็บค่าจำนวนจริงที่มีค่าสูงสุดถึง 3.4 x 1038  และเก็บความละเอียดของทศนิยมได้ถึง 7 ตำแหน่ง เป็นต้นรูปแบบในการประกาศตัวแปรชนิดตัวชี้คือ ชนิดข้อมูล *ชื่อตัวแปร; หรือชนิดข้อมูล* ชื่อตัวแปร; เช่น  int *point; เป็นการประกาศตัวแปรชื่อ point ซึ่งมีชนิดเป็นตัวชี้ที่จะทำหน้าที่เก็บตำแหน่งในหน่วยความจำที่มีข้อมูลชนิดเลขจำนวนเต็มอยู่ ซึ่งเครื่องหมายดอกจัน (*) จะเป็นสิ่งที่ทำให้เราทราบว่าตัวแปร point เป็นตัวชี้การกำหนดค่าเริ่มต้นให้กับโปรแกรมชนิดตัวชี้สามารถกำหนดให้มีค่าเป็น NULL หรือ 0 ซึ่งหมายความว่า ตัวแปรนี้ยังไม่มีการเก็บตำแหน่งที่อยู่ใดๆ นอกจากนี้ยังสามารถกำหนดให้ตัวแปรนี้อ้างอิงไปยังตำแหน่งในหน่วยความจำที่ต้องการซึ่งรายละเอียดในส่วนนี้จะกล่าวถึงในหัวข้อต่อไปห้ามมีเว้นวรรคระหว่างเครื่องหมายดอกจันและตัวแปร เช่น int * error เป็นการประกาศที่ผิดการประกาศตัวแปรชนิดตัวชี้หลายตัวในเวลาเดียวกันสามารถทำได้ เช่น int *ptr1, *ptr2; นอกจากนี้ถ้าต้องการหลีกเลี่ยงการใช้เครื่องหมายดอกจันทุกครั้งที่ประกาศตัวแปรชนิดตัวชี้สามารถทำได้ด้วยการใช้คำหลัก typedef เช่น typedef int* Ptype;Ptype ptr1, ptr2;  2.  ตัวดำเนินการสำหรับตัวชี้ตัวดำเนินการสำหรับตัวชี้มีอยู่ด้วยกัน 2 ตัว คือ ตัวดำเนินการเลขที่อยู่ และตัวดำเนินการอ้างอิง2.1 ตัวดำเนินการเลขที่อยู่ (address operator)ตัวดำเนินการนี้จะใช้เครื่องหมาย & นำหน้าตัวแปร ซึ่งจะหมายความถึงตำแหน่งที่อยู่ของตัวแปรนั้นในหน่วยความจำ ตัวอย่าง 1การอ้างอิงตัวชี้#include<stdio.h>void main(){int z = 10;int *ZPtr;ZPtr = &z;} ข้อความสั่ง ZPtr = &z; มีวัตถุประสงค์เพื่อให้ตัวแปรชนิดตัวชี้ ZPtr เก็บเลขที่อยู่ของตัวแปร z ซึ่งอาจแสดงในรูปแบบตัวชี้ดังรูป 1       

รูปที่ 1 ตัวแปรชนิดตัวชี้ในหน่วยความจำ 2.2 ตัวดำเนินการอ้างอิง (dereferencing operator)ตัวดำเนินการนี้จะใช้เครื่องหมายดอกจัน (*) นำหน้าตัวแปรชนิดตัวชี้ ซึ่งจะเป็นอ้างถึงค่าข้อมูลที่ตัวแปรชนิดตัวชี้นั้นชี้ไป ซึ่งค่าของข้อมูลที่ตัวชี้อ้างอิงนี้สามารถถูกเปลี่ยนแปลงค่าได้ เช่น การเพิ่มค่าอีก 1 สามารถทำได้โดยใช้คำสั่ง (*ptr)++ จะเป็นการเพิ่มค่าที่ตัวชี้ ptr ชี้ไป การแสดงค่าที่ตัวชี้ชี้ไปก็สามารถทำได้โดยใช้คำสั่ง printf(“%d”,ZPtr); จะส่งผลให้โปรแกรมแสดงค่า 10 ออกทางจอภาพตามรูปที่ 1ตัวอย่างที่ 2การใช้งานตัวชี้#include<stdio.h>void main(){int x;int y = 20;int *z;z = &y;x = *z;printf(“%d”,x);} จากส่วนโปรแกรมข้างต้นเมื่อสั่งให้โปรแกรมทำงานจะมีการแสดงค่าตัวแปรของ x ซึ่งมีค่าเป็น 20 ซึ่งเท่ากับค่าที่เก็บอยู่ในตัวแปร y ลำดับเหตุการณ์ที่เกิดขึ้นแสดงดังรูปที่ 2             

รูปที่ 2 ลำดับเหตุการณ์ที่เกิดขึ้นในหน่วยความจำ นอกจากนี้สามารถสั่งให้ตัวแปรชนิดตัวชี้ชี้ไปที่เดียวกันกับตัวแปรตัวชี้ตัวอื่น เช่น ถ้าตัวแปร next มีชนิดเป็นตัวชี้ เราสามารถสั่งให้ชี้ไปที่เดียวกันกับ ที่ตัวแปร z ชี้ไปโดยใช้ข้อความสั่ง next = z;การใช้ตัวดำเนินการแบบอ้างอิงกับตัวแปรชนิดตัวชี้ที่ยังไม่ได้มีการกำหนดค่าจะทำให้เกิดข้อผิดพลาดขึ้นได้เพื่อให้เห็นภาพรวมของการใช้ตัวแปรชนิดตัวชี้กับตัวดำเนินการทั้งสองรูปแบบจึงได้แสดงตัวอย่างโปรแกรมดังนี้ ตัวอย่างที่ 3การแสดงค่าที่เก็บในตัวชี้#include<stdio.h>void main(){int y;int *yPtr;y = 10;yPtr = &y;printf(“The address of y is %p\n”, &y);printf(“The value of yPtr is %p\n”, yPtr);printf(“The value of y is %d\n”, y);printf(“The value of *yPtr is %d\n”, *yPtr);} ค่าที่แสดงตำแหน่งในหน่วยความจำบนจอภาพสำหรับฟังก์ชัน printf(“The address of y is %p\n”,&y); และ printf(“The value of yPtr is %p\n”,yPtr); จะแตกต่างกันไปในแต่ละครั้งของการกระทำการโปรแกรมโดยขึ้นอยู่กับเลขที่อยู่ของหน่วยความจำที่ระบบปฏิบัติการจัดสรรให้ 3.  การใช้ตัวแปรชนิดตัวชี้กับค่าคงที่ตัวแปรชนิดตัวชี้สามารถถูกระบุคุณสมบัติเพิ่มเติมได้โดยการนำคำหลัก const ซึ่งหมายถึงค่าคงที่มาประกอบซึ่งจะมีความหมายแตกต่างกันไปดังนี้1. const int *Ptr; หรือ int const *Ptr หมายถึงการกำหนดให้ตัวชี้ Ptr ชี้ไปที่ข้อมูลตัวเลขจำนวนเต็มที่มีค่าคงที่ ไม่สามารถเปลี่ยนแปลงค่าได้ แต่ตัวชี้ Ptr สามารถเปลี่ยนไปชี้ที่อื่นได้2. int *const Ptr; หมายถึงการบังคับให้ตัวชี้ Ptr ชี้ไปที่ใดที่หนึ่งและห้ามเปลี่ยนตำแหน่งการชี้ แต่ค่าของข้อมูลที่เก็บอยู่ในตำแหน่งนั้นสามารถเปลี่ยนแปลงได้3. const int *const Ptr; หมายถึงการการบังคับให้ตัวชี้ Ptr ชี้ไปที่ใดที่หนึ่งและห้ามเปลี่ยนตำแหน่งการชี้และค่าของข้อมูลที่เก็บอยู่ในตำแหน่งนั้นไม่สามารถเปลี่ยนแปลงได้ 4.  การเรียกใช้ฟังก์ชันที่มีการส่งตัวแปรแบบอ้างอิงการเขียนโปรแกรมที่ดีควรจะมีการแบ่งส่วนชุดคำสั่งการทำงานเป็นกลุ่ม หรือเรียกอีกอย่างหนึ่งว่าฟังก์ชัน โดยส่วนของโปรแกรมหลักจะสามารถสั่งให้ฟังก์ชันทำงานได้โดยการเรียกชื่อฟังก์ชันและส่งตัวแปรที่บรรจุข้อมูลไปยังฟังก์ชันเพื่อให้ฟังก์ชันทำการประมวลผลข้อมูลที่ส่งไป รูปแบบการส่งตัวแปรไปยังฟังก์ชันมี 2 รูปแบบด้วยกันคือ การส่งตัวแปรเฉพาะค่า หรือการเรียกด้วยมูลค่า (call by value) และการส่งตัวแปรแบบอ้างอิงหรือการเรียกด้วยการอ้างอิง (call by reference) ซึ่งวิธีการเรียกโดยมูลค่านี้ได้อธิบายไว้ในเนื้อหาบทที่ 4 ในที่นี้จะขออธิบายถึงการส่งตัวแปรแบบอ้างอิงซึ่งต้องอาศัยตัวแปรชนิดตัวชี้ในการดำเนินการ วัตถุประสงค์ของการส่งตัวแปรอ้างอิงคือการยินยอมให้ฟังก์ชันสามารถทำการเปลี่ยนแปลงค่าของตัวแปรนี้อย่างถาวร หมายความว่าเมื่อฟังก์ชันได้ทำงานเสร็จแล้วค่าของตัวแปรนี้จะมีค่าไม่เหมือนเดิมเมื่อเทียบกับค่าของตัวแปรก่อนเรียกฟังก์ชัน ซึ่งจะได้แสดงให้ดูในตัวอย่างวิธีการส่งตัวแปรแบบอ้างอิงไปยังฟังก์ชันใช้รูปแบบดังนี้ ชนิดข้อมูล ชื่อฟังก์ชัน(&ตัวแปรชนิดตัวชี้) การเขียนส่วนหัวของฟังก์ชันใช้รูปแบบดังนี้ ชนิดข้อมูล ชื่อฟังก์ชัน(ชนิดข้อมูล *ตัวแปรชนิดตัวชี้) ตัวอย่างที่ 4การเรียกฟังก์ชันโดยใช้ตัวชี้#include<stdio.h>void power2(int *);void main(){int num = 3;printf(“The value of num before calling function is %d \n”,num);power3(&num);printf(“The value of num after calling function is %d \n”,num);}void power3(int *Ptr){*Ptr = *Ptr * *Ptr * *Ptr;}จากโปรแกรมในข้างต้นจะเห็นได้ว่าส่วนของโปรแกรมหลักได้ทำการเรียกฟังก์ชัน power3() โดยส่งเลขที่อยู่ของตัวแปร num ไปให้ฟังก์ชันกระทำการ สังเกตที่ส่วนหัวของฟังก์ชัน จะเห็นว่าตัวแปรที่รับค่ามีชนิดเป็นตัวชี้ที่อ้างอิงไปยังข้อมูลชนิดจำนวนเต็ม รูปที่ 3 จะแสดงถึงลำดับเหตุการณ์ที่เกิดขึ้นในหน่วยความจำ                        

รูปที่ 3 ลำดับเหตุการณ์การเรียกฟังก์ชันโดยการส่งตัวแปรแบบอ้างอิงในหน่วยความจำ จากรูปที่ 3 จะสังเกตได้ว่าขณะที่โปรแกรมหลักเรียกฟังก์ชัน power3() โดยส่งเลขที่อยู่ของตัวแปร num ไปให้กับตัวแปรชนิดตัวชี้ชื่อ Ptr ที่ส่วนหัวของฟังก์ชัน จะเกิดการอ้างอิงขึ้นในหน่วยความจำ (สังเกตที่ลูกศร) หลังจากนั้นเมื่อชุดข้อความสั่งในฟังก์ชันกระทำการกับตัวแปรชนิดตัวชี้ Ptr ก็เปรียบเสมือนกับการกระทำการที่ตัวแปร num นั่นเองดังนั้นเมื่อฟังก์ชัน power3() ทำงานเสร็จสิ้นลง และทำงานเสร็จสิ้นลง และทำการแสดงค่าตัวแปร num ออกทางจอภาพ จะได้ค่าใหม่ที่เกิดจากการนำตัวเลขที่เคยเก็บในตัวแปร num ยกกำลังสามตัวอย่างที่ 5การสลับค่าของข้อมูล#include<stdio.h>void flip(int *, int *);void main(){int num1;int num2;printf(“This program will swap to integer\n”);printf(“Please enter number1 and number2 : “);scanf(“%d%d”,&num1,&num2);flip(&num1,&num2);printf(“After swapping num1 is %d num2 is %d\n”, num1, num2);}void flip(int *x, int *y){int temp;temp = *x;*x = *y;*y = temp;} โปรแกรมข้างต้นมีวัตถุประสงค์ในการสลับค่าของตัวแปรที่ผู้ใช้ป้อนเข้ามาโดยการเรียกใช้ฟังก์ชัน flip() ซึ่งรับพารามิเตอร์เป็นตัวแปรชนิดตัวชี้ที่ชี้ไปที่ตัวแปร num1 และ num2 หลังจากนั้นฟังก์ชัน flip() จะทำการสลับค่าในตัวแปรดังกล่าวโดยใช้ตัวชี้ x และ ตัวชี้ y เพื่อให้เข้าใจง่ายขึ้นจึงแสดงรายละเอียดในรูปที่ 4                         

รูป 4  ลำดับการทำงานเมื่อมีการเรียกฟังก์ชันโดยใช้ตัวชี้       ตัวอย่างที่ 6การเพิ่มค่าที่ตัวชี้อ้างอิงโดยการเรียกฟังก์ชัน#include<stdio.h>void increment (int *count_ptr){(*count_ptr)++;}void main(){int count = 0;while(count < 10)increment(&count);} โปรแกรมข้างต้นมีวัตถุประสงค์ในการเพิ่มค่าของตัวแปร count โดยการส่งเลขที่อยู่ของตัวแปร count ไปให้แก่ตัวชี้ count_ptr ที่ฟังก์ชัน increment() ฟังก์ชันดังกล่าวจะทำการเพิ่มค่าของ count ทีละหนึ่ง ฟังก์ชัน main() จะทำการเรียกใช้ฟังก์ชัน increment() จำนวน 10 ครั้ง เมื่อโปรแกรมทำงานเสร็จสิ้นลง ตัวแปร count จะมีค่าเป็น 10 ครั้ง เมื่อโปรแกรมทำงานเสร็จสิ้นลง    ตัวแปร count จะมีค่าเป็น 10จากหลักการส่งตัวแปรไปยังฟังก์ชันจะเห็นว่า การอ้างอิงเลขที่อยู่ของตัวแปรที่เก็บข้อมูลในลักษณะนี้จะทำให้โปรแกรมทำงานได้อย่างมีประสิทธิภาพทั้งในแง่ความเร็วในการประมวลผลและเป็นการประหยัดเนื้อที่ในหน่วยความจำเป็นอย่างมากเมื่อเทียบกับวิธีการส่งตัวแปรแบบเรียกด้วยมูลค่า เนื่องจากการส่งตัวแปรแบบเรียกด้วยมูลค่าจะเกิดกลไกในการคัดลอกข้อมูลจากตัวแปรของผู้เรียกฟังก์ชัน ไปยังตัวแปรที่ส่วนหัวของฟังก์ชัน ซึ่งกลไกนี้จะกินเวลานานถ้าข้อมูลมีขนาดใหญ่ เช่น ข้อมูลชนิดโครงสร้างที่สร้างจากคำหลัก struct ผลที่เกิดตามมาคือจะเกิดการจองเนื้อที่เพื่อเก็บข้อมูลที่เหมือนกันอีกชุดสำหรับฟังก์ชันซึ่งเป็นการสิ้นเปลืองเนื้อที่ อย่างไรก็ตามการส่งตัวแปรแบบเรียกด้วยมูลค่ายังคงมีความสำคัญเนื่องจากบางครั้งอาจไม่ต้องการให้ฟังก์ชันเปลี่ยนแปลงค่าในตัวแปรนั้น  5.  การใช้ตัวชี้กับตัวแปรชนิดแถวลำดับตัวแปรชนิดตัวชี้สามารถช่วยอำนวยความสะดวกในการเข้าถึงข้อมูลที่เก็บอยู่ในแถวลำดับ (array) /ได้ โดยในขั้นตอนแรกจะต้องกำหนดให้ตัวแปรชนิดตัวชี้ชี้ไปยังสมาชิกตัวแรกของตัวแปรแถวลำดับเสียก่อน ซึ่งมี 2 รูปแบบดังนี้รูปแบบที่ 1 ตัวแปรชนิดตัวชี้ = ตัวแปรแถวลำดับ; รูปแบบที่ 2 ตัวแปรชนิดตัวชี้ =  ตัวแปรแถวลำดับ[0]; ตัวอย่างที่ 7 การใช้ตัวชี้ในการอ้างถึงแถวลำดับint a[10];int *aPtr;aPtr = a;                 

รูปที่ 5 ลำดับเหตุการณ์ใช้ตัวแปรชนิดตัวชี้ในการอ้างอิงตัวแปรชนิดแถวลำดับ หลังจากข้อความสั่ง aPtr = a; สามารถใช้ตัวแปรชนิดตัวชี้ในการเข้าถึงข้อมูลในแต่ละสมาชิกของแถวลำดับได้ดังนี้1. การเพิ่มค่าตัวชี้หนึ่งลำดับ (increment pointer)คือ การสั่งให้ตัวชี้เลื่อนไปยังสมาชิกตัวถัดไปหนึ่งลำดับ โดยใช้เครื่องหมายบวกบวก เช่น aPtr++; หรือ aPtr = aPtr +1;2. การลดค่าตัวชี้หนึ่งลำดับ (decrement pointer)คือ การสั่งให้ตัวชี้เลื่อนไปยังสมาชิกตัวก่อนหน้าหนึ่งลำดับ โดยใช้เครื่องหมายลบลบ เช่น aPtr--; หรือ aPtr = aPtr - 1;3. การเพิ่มหรือลดค่าตัวชี้มากกว่าหรือน้อยกว่าหนึ่งลำดับ (add/substract pointer)คือ การสั่งให้ตัวชี้ชี้ข้ามไปยังสมาชิกตัวถัดไปหรือตัวก่อนหน้าตามตัวเลขที่ระบุ เช่น aPtr = aPtr + 2 ; หมายถึงการสั่งให้ตัวชี้ aPtr ชี้ไปยังสมาชิกที่อยู่ถัดไป 2 ลำดับ เช่น ถ้าเดิมตัวชี้ aPtr ชี้อยู่ที่ a[0] เมื่อใช้ข้อความสั่ง aPtr = aPtr + 2 ; จะทำให้ตัวชี้นี้ชี้ไปยังแถวลำดับ a[2]4. การนำตัวแปรชนิดตัวชี้มาลบกันคือการนำตัวแปรชนิดตัวชี้สองตัวมาลบกันซึ่งผลลัพธ์ที่ได้คือ ระยะห่างระหว่างสมาชิกในตัวแปรแถวลำดับ+1 หรือจำนวนสมาชิกที่อยู่ระหว่างตัวชี้ทั้งสองบวกด้วย 1 นั่นเอง เช่น ถ้าตัวชี้ aPtr ชี้อยู่ที่ a[2] และตัวแปรชนิดตัวชี้ bPtr ชี้อยู่ที่ a[5]ข้อความสั่ง x = bPtr-aPtr; จะได้ผลลัพธ์เป็น 35.  การเปรียบเทียบตัวแปรชนิดตัวชี้คือการตรวจสอบว่า ตัวชี้ใดที่ไปที่สมาชิกลำดับที่มากกว่า น้อยกว่า หรือชี้ไปที่สมาชิกตัวเดียวกัน โดยการเปรียบเทียบนี้จะคืนค่าจริงหรือเท็จ ดังนั้นจึงมักนำไปใช้ร่วมกับข้อความสั่ง if หรือข้อความสั่ง while ตัวอย่างเช่นif(aPtr = = bPtr)printf(“finish”);เป็นการตรวจสอบว่า ตัวแปรชนิดตัวชี้ aPtr ชี้ไปที่สมาชิกตัวเดียวกันกับตัวชี้ bPtr หรือไม่คำสั่ง      if(aPtr > bPtr)printf(“aPtr is behind bPtr”); ตัวอย่างที่ 8การประมวลผลแถวลำดับโดยไม่ใช้ตัวชี้#include<stdio.h>int array[] = {4, 5, 8, 9, 8, 1, 0, 1, 9, 3};int index;void main(){index = 0;while (array[index] != 0)++index;printf(“Number of elements before zero %d\n”,index);}โปรแกรมข้างต้นมีวัตถุประสงค์ในการนับจำนวนตัวเลขที่อยู่หน้าเลข 0 โดยไม่ใช่ตัวชี้ จะสังเกตเห็นว่าการเข้าถึงสมาชิกในแถวลำดับทำได้โดยการอ้างถึงชื่อตัวแปรแถวลำดับที่ระบุสมาชิกที่ต้องการ (array[index]) และการเลื่อนไปหาสมาชิกตัวถัดไปทำได้โดยการเพิ่มค่าของตัวแปร index อีก 1 ตัวอย่างที่ 9การประมวลผลแถวลำดับโดยใช้ตัวชี้#include<stdio.h>int array[] = {4, 5, 8 , 9, 8, 1, 0, 1, 9, 3}int *array_ptr;void main(){array_ptr = array;while (*array_ptr != 0)++array_ptr;printf(“Number of elements before zero %d\n”,array_ptr – array);}จากโปรแกรมข้างต้นใช้ตัวชี้ชื่อ array_ptr ในการประมวลผลแถวลำดับและเข้าถึงข้อมูลสมาชิกแต่ละตัวในแถวลำดับด้วย *array_ptr หลังจากนั้นทำการเลื่อนตัวชี้ด้วยข้อความสั่ง ++array_ptr; ตัวอย่างที่ 10การนำตัวแปรชนิดตัวชี้มาประมวลผลกับข้อมูลชนิดแถวลำดับ#include<stdio.h>#include<stdlib.h>void main(){char sentence[10];char *Ptr;int count;Ptr = sentence;for (count = 0; count < 10 ; count++){*Ptr = getchar();++Ptr;}for (count = 0; count < 10 ; count++){--Ptr;putchar(*Ptr);}} โปรแกรมในตัวอย่าง 10 เป็นการนำตัวแปรชนิดตัวชี้ชื่อ Ptr เพื่อรับข้อมูลจากแป้นพิมพ์ทีละอักขระโดยใช้ฟังก์ชัน getchar() และนำมาใส่ในแถวลำดับชื่อ sentence[] เมื่อรับข้อมูลครบทั้งสิบตัวแล้ว โปรแกรมจะทำการแสดงผลลัพธ์โดยแสดงอักขระออกทางจอภาพทีละตัวโดยใช้ฟังก์ชัน putchar() ตัวอย่าง 11การส่งผ่านตัวแปรแถวลำดับไปยังฟังก์ชันโดยใช้ตัวชี้#include<stdio.h>long SumArray(int *tbl,int cl);void main(){int Y[5] = {5, 7, 9, 11, 13};long s;s = SumArray(Y,5);printf(“sum is %d”,5);}long SumArray (int *tbl, int ct){int i;long summ = 0;for(i=0 ; i  < ct ; i++){summ += *tbl;++tbl;}return(summ);} 6.  การใช้ตัวชี้กับสายอักขระตัวแปรชนิดตัวชี้สามารถนำมาประมวลผลกับสายอักขระได้โดยสั่งให้ตัวชี้ชี้ไปที่สายอักขระได้เช่นเดียวกับตัวแปรแถวลำดับโดยไม่ต้องมีเครื่องหมาย & อยู่หน้าตัวชี้ ดังตัวอย่างต่อไปนี้ ตัวอย่างที่ 12โปรแกรมคัดลอกสายอักขระ#include<stdio.h>void strcopy (char *s1,char *s2){while(*s2 != ‘\0’){*s1 = *s2;s1++;s2++;}}void main(){printf(“This program will copy your string \n”);scanf(“%s”,str1);strcopy(str1, str2);printf(“The original string is %s\n”,str1);pritnf(“The new copied string is %s\n”,str2);}