Bảng tra cứu thuật ngữ ngôn ngữ lập trình C/Khai báo biến

Tủ sách mở Wikibooks
Buớc tưới chuyển hướng Bước tới tìm kiếm

Ngôn ngữ lập trình C có một hệ thống mở rộng cho việc khai báo các biến của các kiểu khác nhau. Những qui tắc dành cho các kiểu phức tạp có thể gây nhầm lẫn tùy theo các kiểu thiết kế của chúng. Bài này nói về các khai báo biến, bắt đầu từ các kiểu đơn giản, và dẫn tới các kiểu phức tạp hơn.

Kiểu cơ bản[sửa]

Có 4 kiểu cơ bản của các biến trong C; đó là: char, int, doublefloat.

Tên kiểu Ý nghĩa
char Đơn vị cơ bản nhất có thể địa chỉ hóa được; nó là một byte. Đây là một kiểu nguyên.
int Loại số nguyên theo kích cỡ tự nhiên nhất của các máy tính. Thông thường nó có thể lấy trọn một khoảng có thể địa chỉ hoá được của một word với độ lớn biến thiên từ 16, 23, hay 64 bit tùy theo kiến trúc của CPUhệ điều hành.
float Một giá trị dấu chấm động có độ chính xác đơn.
double Một giá trị dấu chấm động có độ chính xác kép.

Để khai báo một biến có kiểu cơ bản, tên của kiểu được ghi ra trước sau đó đến tên của biến mới (hay của nhiều biến mới cách phân cách nhau bởi dấu phẩy) -- (Xem thêm định nghĩa dãy điểm)

char red;
int  blue, yellow;

Các định tính khác nhau có thể đặt vào trong các kiểu cơ bản này để điều chỉnh kích cỡ và sẽ được miêu tả trong phần sau.

Lưu ý: Ở đây chỉ nêu ra trường hợp khai báo đơn giản không đi kèm với việc gán giá trị khởi động cho biến

Dấu[sửa]

Một kiểu được gọi là có dấu nếu kiểu nguyên đó có thể chứa các số âm. Ngược lại các kiểu cơ bản nào không chấp nhận các số âm là kiểu không dấu.

Có hai kiểu nguyên là charint có thể có dấu âm hay không. Theo mặc định thì mọi kiểu int là có dấu (nghĩa là chúng chấp nhận các số âm). Để dùng dưới dạng không có dấu (tức là kiểu nguyên chỉ chấp nhận các sô không âm) thì từ khoá unsigned phải được dùng. Ngoài ra, thay vì khai báo đầy đủ trong dạng unsigned int, người ta có thể lược bỏ bớt từ khóa int (và nó được xem như hiểu ngầm -- điều này chỉ dùng đưọc cho kiểu int mà thôi). Như vậy hai khai báo sau đây hoàn toàn tương đương:

 unsigned int green;
 unsigned green;

Đặc tả của C không xác định rõ ràng là kiểu char sẽ là loại có dấu hay không dấu; khi đó, dấu của kiểu này tùy thuộc vào quy định của nhà phát hành trình dịch. Như vậy, một cách để giảm sai sót khi làm việc trên nhiều loại trình dịch C khác nhau là khai báo rõ ràng bằng các định tính signed hay unsigned nếu dùng kiểu char để tính toán trên các con số. (Dầu sao, nó thực sự sẽ không quá quan trọng nếu dùng kiểu char như là kiểu "ký tự".)

unsigned char grey;
signed char white;

Tiêu chuẩn chung yêu cầu char, signed char, unsigned char là các kiểu khác nhau. Ngoài ra, các hàm chuẩn về dãy các kí tự sử dụng các con trỏ chỉ tới kiểu char (không có định tính), nhiều trình dịch C sẽ bắt lỗi (hay cảnh cáo) nếu các kiểu kí tự khác được dùng như là dãy kí tự được chuyển vào các hàm này.

Kích cỡ[sửa]

Trong phần này hai cụm từ "chiếm" và "có độ dài" đều có nghĩa là "phần bộ nhớ cần thiết để dành cho một biến"; biến này có kiểu được miêu tả tùy theo chi tiết của bài viết.

Kiểu int cũng có các định tính về kích cỡ để đặc biệt hóa tầm rộng của giá trị mà kiểu này cho phép (tương ứng với đó là việc thay đổi phần bộ nhớ dùng để chứa các số có kiểu này).

short int yellow;
long int orange;

Tương tự như đã đề cập trong phần trước, người ta có thể bỏ không viết từ khóa int trong các kiểu mà đầy đủ phải viết là short int or long int. Thí dụ hai khai báo sau đây là tương đương.

long int brown;
long brown;

Có một số nhầm lẫn trong giới hiểu biết về C như là các kiểu nguyên có độ lớn bao nhiêu. Trong tiêu chuẩn thì không chỉ một cách rõ ràng việc này:

  • Kiểu short int không thể lớn hơn kiểu int.
  • Kiểu int không thể lớn hơn long int.
  • Kiểu short int phải dài ít nhất 16 bit.
  • Kiểu long int phải dài ít nhất 32 bit.

Trong tiêu chuẩn đã không đòi hỏi gì về các kích cỡ nêu trên và những khác nhau cần thiết. (Nghĩa là hoàn toàn hợp lệ nếu cả ba kiểu đều dài 64 bit!) Để có được một miêu tả chính xác và đơn giản của các kiểu, một máy tính người ta áp dụng vào trong mỗi kiểu (cũng như là kích cỡ của một kiểu con trỏ; xem phần đưới đây) một loại lược đồ đã được tạo ra; (xem :64-Bit Programming Models). Hai lược đồ được biết nhiều nhất là

  • ILP32, trong đó int, long int và các kiểu con trỏ chiếm 32 bit.
  • LP64, trong đó, long int và con trỏ mỗi loại chiếm 64 bit, còn int có độ dài 32 bit.

Hầu hết các trình dịch dùng các lược đồ trên dùng 16 bit cho kiểu short int.

Một biến double có thể là môt long double, mà trình dịch có thể sử dụng thay cho một kiểu double thuần túy. Tương tự tình huống trước, chuẩn C không hề nêu rõ các kích cỡ tương đối giữa các giá trị dấu chấm động, mà chỉ đòi hỏi float không được lớn hơn long double về kích cỡ.

Từ khóa định tính const cho các kiểu[sửa]

Để giúp tăng cường độ an toàn trong các chương trình, các giá trị có thể được đánh dấu là các hằng bằng từ khóa định tính const. Với từ khóa này thì một biến khai báo trở thành một hằng. Mọi thao tác do vô ý hay cố ý để điều chỉnh giá trị của nó sẽ bị báo lỗi bởi hầu hết các trình dịch. Bởi vì sau khi đã dùng từ khóa định tính const thì các giá trị của biến không thể thay đổi nữa nên người lập trình phải gán giá trị ban đầu ngay lúc khai báo.

Chuẩn C cho phép hoán đổi vị trí của các hiệu chính. Thí dụ cả hai khai báo hằng sau đây là tương đương

int const black = 12;
const int black = 12;

Cách khai báo đầu thường phản ánh cách dùng const trong cách dùng kiểu con trỏ trong khi cách thứ nhì lại tự nhiên hơn và phổ dụng hơn.

Con trỏ[sửa]

Một biến có thể được khai báo như là một con trỏ chỉ đến các giá trị có kiểu nào đó, với ý nghĩa của dùng từ khóa định tính *. Để khai báo chỉ việc viết thêm ngay trước tên biến một dấu sao:

char *square;
long *circle;

Lưu ý: Nếu dùng nhiều hơn một dấu sao thì sẽ tạo nên dạng các con trỏ đứng trước chỉ vào con trỏ đứng sau và con trỏ cuối cùng mới chỉ đến địa chỉ của giá trị biến.

Trong cuốn "The C Programming Language" (Ngôn ngữ lập trình C) có cho một giải thích tường tận về việc "hơi kì cục" khi dùng dấu sao trước tên của biến, trong khi dường như việc dùng dấu sao này đứng trước tên của kiểu thì có vẻ "hợp lý" hơn. Đó chính là việc tham chiếu ngược con trỏ, nó có kiểu của đối tượng mà nó chỉ tới. Trong thí dụ trên, *circle là một giá trị của kiểu long. Trong khi điều này khó thấy rõ trong thí dụ trên, thì nó lại cho thấy ưu điểm nếu dùng trong các kiểu phức hợp. Đây là lí do tại sao C "hơi kì cục" trong cách khai báo các kiểu phức hợp, lúc đó, tên của biến sẽ không còn rõ ràng trong khi khai báo kiểu như các thí dụ sẽ nêu trong phần tiếp sau đây.

Có một kiểu đặc biệt của giá trị mà không thể dùng được trực tiếp như là biến có kiểu, nhưng lại có thể chỉ đến nó nếu khai báo con trỏ.

void *triangle;

Giá trị được chỉ tới ở đây không thể dùng trực tiếp đuợc; mọi cố gắng để tham chiếu ngược con trỏ này sẽ dẫn tới một lỗi. Sự tiện lợi ở đây là vì nó là một con trỏ "tổng quát"; nó hữu dụng khi làm việc trên dữ liệu mà kiểu được chỉ tới là không giữ vai trò gì quan trọng. Đơn giản chỉ cần cái địa chỉ con trỏ. Nó thường được ứng dụng để chứa các con trỏ trong các kiểu để làm tiện ích như là danh sách liên kết, bảng băm (hash). Khi nào cần thì tiện ích sẽ đổi kiểu (typecast) thành con trỏ có kiểu cần dùng.

Sau đây là thí dụ về các khai báo con trỏ hợp lệ:

long int *rectangle;
unsigned short int *rhombus;
const char *kite;

Lưu ý đặc biệt về việc dùng const trong trường hợp cuối cùng: ở đây kite là một con trỏ không phải là hằng chỉ tới một const char (tức là nó chỉ tới là một hằng có kiểu kí tự). Giá trị của kite tự nó không phải là hằng, chỉ có giá trị của char mà nó chỉ tới là một hằng.

Vị trí của từ khoá const đặt sau kiểu sẽ cho một cách thức để khai báo hằng con trỏ. Và như là một hằng, nó phải được gán giá trị khởi động khi khai báo:

char * const pentagon = &some_char;

Ở đây, pentagon là một hằng con trỏ, mà nó chỉ tới một char. Giá trị mà nó chỉ tới lại không là một hằng; và sẽ không gây lỗi khi thay đổi kí tự được nó chỉ tới. Chỉ khi nào thay đổi chính con trỏ này thì sẽ gây lỗi (vì đã khai báo nó là hằng). Cũng có thể khai báo cả hai: con trỏ và giá trị mà nó chỉ tới đều là hằng. Có hai cách tương đương nếu muốn khai báo như vậy là:

char const * const hexagon = &some_char;
const char * const hexagon = &some_char;

Con trỏ chỉ tới con trỏ[sửa]

Vì lý do một khai báo chẳng hạn như char * tự nó là một kiểu, nên một biến con trỏ có thể được khai báo để nó chỉ vào các giá trị có kiểu như vây. Nói gọn hơn, chúng là con trỏ chỉ tới các con trỏ. Thí dụ:

char **septagon;

Như đã đề cập phần trên các từ khóa định tính const có thể áp dụng vào chẳng hạn:

unsigned long const int * const *octogon;

Dòng trên khai báo octogon là một con trỏ chỉ tới một hằng con trỏ, và hằng con trỏ này trở lại chỉ tới một số nguyên dạng unsigned long. Các kiểu con trỏ có thể lồng nhau, nhưng chúng càng trở nên khó khăn để nghĩ tới việc sử dụng khi mà càng nhiều cấp độ của sự gián tiếp tham gia vào. Mọi mã dùng nhiều hơn hai cấp độ của con trỏ có thể sẽ cần tới một sự thiết kế, dạng struct các con trỏ.

'Chữ đậm'Chữ đậm


Mảng[sửa]

Đối với nhiều người lập trình, trong hầu hết các ngôn ngữ tương tự C, kiểu của một mảng nằm trong số phần tử mà nó chứa. Do vậy, khai báo sau đây có thể dùng trong các ngôn ngữ như Java hay C# để khai báo một mảng 10 giá trị số nguyên.

int[10] cat; /* THIS IS NOT VALID C CODE */

Mặc dù vậy, như đã nhắc tới trước đây, nguyên lý trong cú pháp khai báo của C làm cho việc khai báo tương tự như việc sử dụng của biến. Thí dụ: một truy cập tới mảng này chẳng hạn như là cat[i], lúc khai khai báo lại cũng có cú pháp dạng:

int cat[10];

Mảng của các mảng[sửa]

Tương tự như con trỏ, kiểu mảng có thể được lồng nhau. Vì trong cách viết mảng sử dụng các ngoặc vuông ([]), là một cách viết hậu tố, nên kích cỡ của mảng bên trong thì được ghi ở bên ngoài (hay đằng sau):

double dog[5][12];

Câu lệnh trên khai báo rằng dog là một mảng có năm phần tử. Mỗi phần tử là một mảng của 12 giá trị double.

Mảng của các con trỏ[sửa]

Vì kiểu của phần trong một mảng tự nó lại là một kiểu của C, mảng của các con trỏ đương nhiên cũng có cấu trúc:

char *mice[10];

Câu lệnh này khai báo biến mice là mảng của 10 phần tử, trong đó, mỗi phần tử là một con trỏ chỉ tới char.

Con trỏ chỉ tới các mảng[sửa]

Để khai báo một biến là một con trỏ chỉ tới một mảng, nhất thiết phải dùng tới dấu ngoặc đơn. Nó tương tự như cách dùng ngoặc để đổi thứ tự ưu tiên cho phép toán (phép toán trong ngoặc sẽ được tính trước) chẳng hạn:

2 + 3 * 4
(2 + 3) * 4

Hoàn toàn tương tự cho con trỏ chỉ tới các mảng. Lưu ý rằng dấu ngoặc vuông ([]) có độ ưu tiên cao hơn dấu sao (*), do đó khai báo sẽ có dạng:

double (*elephant)[20];

Câu lệnh này khai báo biến elephant là một con trỏ, và nó chỉ tới một mảng có 20 giá trị kiểu double.

Để khai báo một con trỏ chỉ tới dãy các con trỏ, chỉ cần kết hợp các cách viết:

int *(*crocodile)[15];


Cấu trúc[sửa]

Cấu trúc (từ khóa tương ứng struct) thực sự là một "kiểu mở rộng" của mảng. So với mảng thì cấu trúc mạnh hơn ở chỗ nó cho phép các phần tử của nó có các kiểu khác nhau và mỗi phần tử này được gọi là thành phần của một cấu trúc:

 struct person 
 {
     char name[60];
     int age;
 }; //lưu ý dấu ";" cần dùng để kết thúc câu lệnh

Câu lệnh struct nêu trên là một khai báo chuẩn để tạo ra một kiểu cấu trúc trong C.

Định nghĩa biến kiểu struct[sửa]

Việc định nghĩa một biến có kiểu struct cũng đơn giản như khi định nghĩa các biến bình thường:

 struct person Bluesman;
 
 struct person Bio =
 {
   "Hieu",
   30
 };

Trong cách đầu thì biến Bluesman chưa có giá trị khởi động (nó vẫn có thể được truy cập và thay đổi giá trị sau này) trong khi biến Bio đã được gán các giá trị ban đầu. Hãy lưu ý dùng dấu phẩy "," để phân biệt các giá trị được gán lên những thành phần của cấu trúc -- và dĩ nhiên chúng phải có đúng kiểu cũng như không thể gán thiếu các giá trị cho các thành phần này.

Để truy cập đến các giá trị của biến có kiểu struct thì có thể dùng toán tử "." như câu lệnh sau:

  printf("Name : %s\n", Bio.name);

Mảng của các struct[sửa]

Để kiến tạo một mảng của các struct thì dùng cú pháp sau:

  struct person list[10];

Con trỏ chỉ tới struct[sửa]

Cũng vậy, việc tiến hành khai báo một biến con trỏ có kiểu là struct tương tự cách thông thường. Chỉ cần thêm vào đó dấu sao đằng trước tên biến:

  struct person *Huong;

Cấu trúc lồng nhau[sửa]

Kiểu cấu trúc cũng có thể định nghĩa lồng vào nhau. Thí dụ dưới đây cho thấy việc khai báo cấu trúc worker có chứa cấu trúc person như là một thành phần. Việc truy cập dữ liệu thành phần của cấu trúc bên trong cũng được tiến hành theo cách dùng toán tử "." nối tiếp nhau.

 struct person
 {
     char name[60];
     int age;
 };
 struct worker
 {
    struct person peronal_ID;
    char job[30];
    float income;
 };

Kiểu hợp nhất[sửa]

Kiểu hợp nhất có tên từ khóa là union kiểu đặc biệt này cho phép nó chứa dữ liệu mà có thể có kiểu khác nhau trong cùng một phần bộ nhớ (mà nó có thể được cấp phát khi khai báo biến):

 union folder
 {
   int number;
   double real;
   char letter;
 }; //lưu ý dấu ";" cần dùng để kết thúc câu lệnh

Để khai báo biến, có thể dùng cách thông thường, tạo mảng các union hay cách tham chiếu:

 union folder matter;
 union folder listtype[100];
 union folder *matterptr;

Để gán hay truy cập giá trị cho một biến union, có thể dùng toán tử "." Theo hàng khai báo đầu tiên của thí dụ trên ta có thể viết một trong các phép gán:

 matter.real=3.1416;

hay là:

 matter.letter = 't';

hay là:

 matter.number = 1;

Lưu ý:

  • Việc gán giá trị cho một biến kiểu union đòi hỏi kiểu của dữ liệu đó phải có mặt trong khai báo ban đầu của nó. Theo thí dụ trên thì kiểu folder chỉ chấp nhận chứa một đơn vị dữ liệu của một trong ba kiểu int, double,char.
  • Một khi giá trị có kiểu đúng nào đó được gán cho một biến kiểu union thì nó sẽ xóa bỏ hẳn giá trị cũ (nếu có) mà biến này đã chứa trước đó.
  • Việc truy cập một giá trị từ một biến kiểu union cần lưu ý đến kiểu hiện tại của dữ liệu đang được chứa của biến này nếu không, có thể gây ra lỗi dùng sai kiểu.
  • Điểm khác nhau quan trọng giữa unionstructunion chỉ có được một thành phần (nhưng thành phần này phải có kiểu tùy theo khai báo của người lập trình) trong khi struct bao gồm nhiều thành phần (và mỗi thành phần có thể có kiểu khác nhau).
  • Tương tự như strruct, union cho phép khai báo nhiều union lồng nhau.

Dùng #define để định nghĩa hằng và kiểu[sửa]

Một cách tổng quát thì từ khóa tiền xử lý #define đùng để định nghĩa tên của một kiểu (đối tượng) nào đó. Thực ra, câu lệnh #define chỉ là một loại câu lệnh macro. Có hai ứng dụng chính như sau:

Định nghĩa tên hằng[sửa]

Có thể dùng câu lệnh tiền xử lý #define để định nghĩa một hằng:

 #define PI 3.14159           //định nghĩa tên một hằng số PI
 #define STANDARD "ANSI C"    //định nghĩa tên một hằng dãy kí tự 
 #define ESC '\033'           //định nghĩa tên một hằng kí tự mã ASCII của phiếm Esc.

Lưu ý: so với cách định nghĩa dùng từ khóa const thì cách dùng này không được uyển chuyển bằng nhưng nó thường cho hiệu quả thực thi nhanh hơn vì đây chỉ là các macro.

Định nghĩa tên của kiểu dữ liệu[sửa]

Có thể dùng #define để định nghĩa tên của một kiểu dữ liệu:

 #define real float  //định nghĩa tên kiẻu real cho dữ liệu có kiểu float

Việc khai báo các biến không có gì khác lạ ngoại trừ tên mới được dùng:

 real x, y[3], *z;

Lưu ý: Việc sử dụng #define có thể có các hiệu ứng phụ không ngờ nếu dùng nó kết hợp với nhiều định tính và có thể dẫn đến những lỗi khó tìm khi viết mã:

 #define STRING char *

Trong lúc định nghĩa biến người lập có thể muốn định nghĩa hai con trỏ char như sau:

 STRING name, job;

Tuy nhiên, điều ước muốn sẽ không xãy ra vì #define là macro nên trình dịch sẽ diển giải thành (nó chỉ thay thế tên STRING bằng char *):

 char * name, job;

Và như vậy, người lập trình sẽ không nhận được hai biến con trỏ như dự tính mà chỉ có một biến name là con trỏ mà thôi.

Dùng typedef để định nghĩa kiểu[sửa]

Một cách khác để đặt tên riêng cho kiểu dữ liệu là dùng câu lệnh với từ khóa typedef:

 typedef float real;

Nếu so sánh cách viết trong thí dụ trên với việc dùng từ khoá #define để định nghĩa thì chúng hoàn toàn tương đương (chỉ khác nhau về thứ tự các chữ floatreal). Tuy nhiên, cách viết này là một sự thay thế thế tên "đúng nghĩa" chứ không phải là một macro đơn thuần. Trở lại thí dụ:

  typedef char* string;

Câu lệnh trên cho phép đặt tên string như là một kiểu mới (mà nội dung của nó là kiểu con trỏ char). Bây giờ hãy xét đến câu lệnh khai báo biến:

  string name, job;

Trường hợp này sẽ được trình dịch diễn dịch đúng theo mong muốn thành:

  char *name, *job;

Dùng cho struct[sửa]

Một thí dụ khác liên quan đến việc đặt tên cho struct là việc kết hợp cả hai khai báo và đặt tên lại trong cùng một câu lệnh:

  typedef struct
  {
     char * name;
     int * age;
  }  person;

Như vậy khi khai báo biến chỉ cần viết là:

 person Trung;

Ứng dụng[sửa]

Một ứng dụng đáng lưu ý của typedef là việc làm cho mã C trở nên linh hoạt hơn trong nhiều môi trường khác nhau. Thí dụ: khi muốn xác định dùng đúng 4 byte cho một kiểu nguyên nhưng trên một số hệ máy thì nó ứng với kiểu int, trong khi trên một số hệ máy khác nó lại ứng với kiểu long int. Để giải quyết việc dùng chính xác 4 byte cho kiểu nguyên mà người lập trình muốn, thì có thể dùng giải pháp là: thêm vào một tập tin bao gồm trong đó có chứa định nghĩa:

  typedef int FOURBYTE;  //dùng cho các máy lấy int là 4 byte

hay định nghĩa:

  typedef long int FOURBYTE;  //dùng cho các máy lấy long int là 4 byte

và chỉ cần thêm vào trong mã nguồn câu lệnh #include <Tên_tập_tin_bao_gồm> như vậy chỉ cần thay nội dung của tập tin bao gồm thì toàn bộ mã vẫn hoạt động đúng.

Kiểu enum[sửa]

Kiểu enum là một kiểu dữ liệu đặc biệt được dùng để định nghĩa một quan hệ thứ tự cho một tập họp hữu hạn các tên. (Trong thực tế thì enum có kiểu là int -- Theo trang 553 trong cuốn "New C Primer Plus" -- xem thêm phần tham khảo):

 enum Wiki {Arisa, Bluesman, VietBio, Trung, Quang, Minh};

Để khai báo biến member có kiểu enum dùng câu lệnh:

 enum Wiki member;

Các giá trị (hiểu ngầm) của các kí hiệu Arisa, Bluesman, VietBio, Trung, Quang, Minh theo mặc định sẽ tương ứng với 0, 1, 2, 3, 4, 5. Các câu lệnh cách viết sau đây là có hiệu lực:

  member = Minh;
  if (member == VietBio) { do_some_commands }
  for (member=Arisa; member <= Trung; member++) { do_some_commands }

Như vậy, theo mặc định, các tên của một enum</cdoe> được xem là các {duck, cahằng số từ 0 tăng dần cho đến tên cuối cùng.

Tuy nhiên, C không loại trừ khả năng xếp lại giá trị của một kiểu enum theo cách riêng:

  enum reordert=10, mouse =50, elephant =1000, lion, virus};

Trong thí dụ trên thì duck có giá trị tương ứng là 0, cat là 10, ..., elephant là 1000, còn lion tương ứng với giá trị 1001 và virus tương ứng với 1002.

Một trong những ứng dụng chính của kiểu này là để tăng cường khả năng đọc mã được dể hiểu hay phù hợp hơn.


Lưu ý về biến được khai báo static[sửa]

Các biến có được xác định bởi định tính static đặt trước tên kiểu biến khi khai báo sẽ cho biến đó một tính năng đặc biệt, đó là, giá trị của nó sẽ được lưu giữ không bị mất đi mặc dù khối mã chứa nó đã được xử lí xong. Trường hợp. đặc biệt nếu một biến được khai báo có định tính static trong một hàm và được cài đặt giá trị nào đó thì sau khi hàm đó được gọi, giá trị của biến static đó vẩn còn giữ nguyên giữa mỗi lần gọi (cho tới khi nó được gán giá trị khác trong lần gọi tới của hàm). Thi dụ sau đây khai báo biến my_static có định tính static trong một hàm:

 #include<stdio.h>
 int static_func(int init)
 {
    static int my_static_var;
    my_static_var += init;
    return my_static_var;
 }
 int main(void)
 {
   printf("call the 1st time (init=0), my_static_var = %d\n", static_func(0));
   printf("call the 2nd time (init=1), my_static_var = %d\n", static_func(1));
   printf("call the 3rd time (init=2), my_static_var = %d\n", static_func(2));
 }

Sau khi dịch và chạy mã này sẽ cho kết quả:

   call the 1st time (init=0), my_static_var = 0   //0 +0 =0
   call the 2nd time (init=1), my_static_var = 1   //0 +1 =1
   call the 3rd time (init=2), my_static_var = 3   //1 +2 =3

Lưu ý: Mọi biến toàn cục đều có định tính static một cách tự động.