CFSDN nhấn mạnh vào giá trị tạo ra nguồn mở và chúng tôi cam kết xây dựng nền tảng chia sẻ tài nguyên để mọi nhân viên CNTT có thể tìm thấy thế giới tuyệt vời của bạn tại đây.

Bài viết trên blog CFSDN này sẽ đưa bạn qua những kiến ​​thức về toán tử ngôn ngữ C được tác giả sưu tầm và biên soạn. Nếu bạn quan tâm đến bài viết này thì nhớ like nhé.

Toán tử và biểu thức

Hôm nay chúng ta đã hiểu sơ bộ các toán tử trong ngôn ngữ C ban đầu.

  。

Toán tử

Có rất nhiều toán tử trong ngôn ngữ C, nhưng sau khi phân loại đại khái sẽ có những toán tử sau.

//Toán tử số học + - * / %//Toán tử dịch chuyển<< >>//Toán tử bit& |//Toán tử gán = += -= *= /= ...//Toán tử một chiều sizeof() ! & * //Toán tử quan hệ > >= < <= ==//Toán tử logic && ||//Toán tử có điều kiện?://biểu thức dấu phẩy,//Các toán tử khác [ ] () -> .

toán tử số học

Các toán tử số học đều quá phổ biến, .

Cộng, trừ, nhân, chia và lấy phần còn lại.

Các toán tử + - * / giống như toán tử của chúng ta.

Điều này đáng lưu ý.

/ 。

int c=10/3; c=10.0/3; c=10/3.0; // Kết quả của c là 3 (double)c=10.0/3; //Có thể tính được giá trị thập phân

Trong ngôn ngữ C, / cần ít nhất một toán hạng là số dấu phẩy động để kết quả là số dấu phẩy động và hãy nhớ rằng nó tồn tại trong số dấu phẩy động.

Toán tử % còn lại (modulo).

Chỉ có thể tính được kết quả giữa hai loại số nguyên và kết quả cũng là loại số nguyên.

toán tử thay đổi

Sự thay đổi được đề cập ở đây đề cập đến việc di chuyển các bit nhị phân.

Có toán tử dịch trái và toán tử dịch phải.

<< toán tử dịch trái.

Dịch các bit nhị phân sang trái.

Có thể thấy rằng sau khi dịch trái nhị phân, a<<1 gấp 2 lần a, nên ta có thể biết rằng khi dịch chuyển một bit sang trái thì nó được mở rộng lên 2 lần.

Dịch sang trái n bit và mở rộng thêm 2^n lần.

>>Toán tử dịch chuyển phải.

Như bạn có thể tưởng tượng, toán tử dịch chuyển phải có tác dụng tương tự như dịch chuyển trái, di chuyển bit nhị phân sang phải một bit.

Các bit nhị phân ở bên phải bị loại bỏ và các bit nhị phân ở bên phải không được thêm số 0 như toán tử dịch chuyển trái. Điều này cần được thảo luận theo từng trường hợp cụ thể.

Các ca được chia thành các ca số học và các ca logic.

Khi phép dịch số học có nghĩa là phép dịch phải, bit cần thêm vào bên trái cần nhìn vào bit dấu nhị phân và cộng nó. Bit nào được thêm vào giống như bit dấu.

Dịch chuyển logic có nghĩa là bất kể đó là thao tác dịch trái hay dịch phải, 0 sẽ được thêm vào bất kỳ bit nào được thêm vào.

Nhưng khi chúng ta cần di chuyển một số âm, hiển nhiên phép dịch logic sẽ làm thay đổi giá trị của số ban đầu thành dương hoặc âm.

Do đó, dịch chuyển số học được sử dụng trong các trình biên dịch chung.

Bạn có thể thấy rằng giá trị ban đầu của thao tác dịch chuyển phải giảm đi 2^n lần.

Lưu ý: Cả ca trái và ca phải đều phải xem xét liệu tình trạng tràn có xảy ra sau ca làm việc hay không.

Phép dịch chuyển dùng để di chuyển các chữ số dương, .

Lỗi dịch chuyển a>>-1 này không được xác định trong ngôn ngữ C.

Toán tử bit

Các phép toán bit bao gồm & (bitwise AND), | (bitwise OR), ^ (bitwise XOR) ~ (phủ định bitwise).

Như tên cho thấy, toán tử bitwise là các phép toán trên bit nhị phân. Chúng có hai toán hạng và thực hiện các phép toán trên bit nhị phân.

Ở đây các bit nhị phân của chúng ta đều đề cập đến mã bổ sung, bởi vì một số được lưu trong bộ nhớ dưới dạng mã bổ sung.

// 00000000 00000000 00000000 00100010// 00000000 00000000 00000000 11010110// & 00000000 00000000 00000000 00000010 // | 00000000 00000000 00000000 11110110// ^ 00000000 00000000 00000000 11110100 

Toán tử bit	tác dụng
&	Các chữ số nhị phân của cả hai toán hạng đều đúng (1) và kết quả là đúng (1) nếu không thì kết quả là sai (0)
|	Nếu các chữ số nhị phân của hai toán hạng là sai (0) thì kết quả là sai (0); nếu không thì kết quả là đúng (1)
^	Một đúng (1) và một sai (0). Kết quả là đúng (1), nếu không thì sai (0).
~	Đảo ngược bit của các bit nhị phân, 1 trở thành 0, 0 trở thành 1

Ứng dụng của toán tử bit

// Hãy thử viết mã này bao gồm int main(){ int num1 = 1; //00000000 00000000 00000000 00000001 int num2 = 2; //00000000 00000000 00000000 00000010 num1 & num2; // 00000000 00000000 00000000 num1 | // 00000000 00000000 00000000 00000011 num1 ^ num2; 00000000 00000011 trả về 0;}

Một câu hỏi phỏng vấn để kiểm tra kỹ năng của bạn

Không tạo biến mới, trao đổi hai biến.

//Số thứ tự#includeint main(){int a=3; // 00000000 00000000 00000000 00000011int b=5; // 00000000 00000000 00000000 00000101a=a^b; // 0000000 0000000 0000000 00000110b=a^b; // 0000000 0000000 0000000 00000110b=a^b; // 0000000 0000000 0000000 00000011a=a^b; // 0000000 0000000 0000000 00000011a=a^b; // 0000000 0000000 0000000 000000101}

Một đoạn mã thú vị sử dụng ^ XOR bitwise để trao đổi hai số.

^Thuộc tính của toán tử XOR.

a^a=0,

a^0=a,

Thường sử dụng hai thuộc tính này để giải quyết vấn đề và viết mã xuất sắc! .

//Hướng dẫn sử dụng#includeint main(){int a=3;int b=5;a=a+b; //a=8b=ab; // b=3a=ab; // a=5}

Tìm số số nhị phân được lưu trong bộ nhớ của một số nguyên.

//Phương thức 1 #includeint main(){int n=10;int count=0;while(n){ if(n%2==1) { count++ } n>>=1; }printf("Nhập số chữ số nhị phân 1: %d",count);}

Hãy suy nghĩ xem liệu đoạn mã trên có vấn đề gì không.

Khi n là số âm?

Bạn có thể thấy rằng chương trình sẽ tiếp tục theo một vòng lặp vô hạn.

Hãy tối ưu hóa nó! .

//Phương thức hai #includeint main(){ int i=0; int count=0; int num=-3; for(i=0;i<32;i++) { if((num> >i)&1==1) //Shift và xác định xem bit cuối cùng có phải là 1 count++ } return 0;}

Mỗi chu kỳ phải được thực hiện 32 lần. Chúng ta có thể tối ưu hóa lại không? .

//Phương thức ba #include int main(){ int num = -1; // 10000000 00000000 00000000 00000001 // Mã bổ sung 11111111 11111111 11111111 11111111 int i = 0; 0;//Đếm while(num) { count++; num = num&(num-1);//Bỏ chữ số cuối cùng 1 } printf("Số 1 trong hệ nhị phân = %d\n",count return 0 ; }

Đoạn mã trên có tuyệt vời không? Hầu hết mọi người đều không mong đợi nó. .

toán tử gán

Tất cả chúng ta đều quen thuộc với toán tử gán.

Chúng ta có thể thay đổi một biến thành giá trị bạn muốn thông qua toán tử gán! .

#includeint main(){ int trọng lượng=180; trọng lượng=125; // Bạn có thể thay đổi nếu không hài lòng // Phép gán liên tục int a=13,b=0,c=0; =b=c= 6; // Nhược điểm của thao tác gán liên tục là không dễ gỡ lỗi}

toán tử gán ghép

+= -= *= /= %= … 。

Bạn có thể thấy nhiều toán tử gán ghép.

 a+=2; ===> a=a+2; a*3; ===> a=a*3; // Các toán tử khác giống nhau....

Đây là toán tử gán ghép, rất đơn giản và thuận tiện để sử dụng! .

Toán tử một ngôi

//Toán tử một ngôi là toán tử chỉ có một toán hạng! + - ! sizeof() ++ -- ~ * (loại)

+ - 。

+ - ở đây là tất cả các toán tử một ngôi, không phải +- trong toán tử số học.

  a=-5; //-5 ở đây đề cập đến toán tử đơn nhất! b=+5; //+5 + có thể được bỏ qua!

! Toán tử nghịch đảo logic.

while(a!=0) //Đây rồi! Toán tử nghịch đảo logic { count++; //a không phải là 0count++;}while(!a){count++; //a là 0count++;}

kích thước của 。

Bạn có ngạc nhiên khi sizeof thực sự là một toán tử không? .

sizeof là một toán tử đặc biệt, không phải là một hàm! .

Chúng tôi biết rằng sizeof có thể tính toán dung lượng và kích thước bộ nhớ bị chiếm bởi một biến và loại! .

int main(){ int a = -10; int* p = NULL; printf("%d\n", !2); printf("%d\n", !0); &a; printf("%d\n", sizeof(a)); printf("%d\n", sizeof(int)); printf("%d\n", sizeof a); // Viết như thế này có ổn không? printf("%d\n", sizeof int);//Viết như thế này có ổn không? trả về 0;}

Bạn có thể thấy khi sizeof tính toán một kiểu, nếu không thêm dấu ngoặc đơn thì sẽ báo lỗi. Tuy nhiên, khi tính kích thước của một biến thì có thể bỏ qua dấu ngoặc đơn! .

Tóm tắt: Khi sizeof tính toán kích thước bộ nhớ mà một loại chiếm giữ, không thể bỏ qua dấu ngoặc đơn. sizeof(type), khi tính toán kích thước bộ nhớ bị chiếm bởi một biến, sizeof(variable), sizeof biến.

Thay đổi lỗi và xem kết quả! .

sizeof và mảng.

Chúng ta biết rằng sizeof có thể tính kích thước không gian của một biến nên chúng ta thường sử dụng sizeof để tính số phần tử trong một mảng! .

Công thức: sizeof (mảng)/sizeof (một phần tử của mảng).

#include void test1(int arr[]){ printf("%d\n", sizeof(arr));//(2)}void test2(char ch[]){ printf("%d\n", sizeof(ch));//(4)}int main(){ int arr[10] = {0}; char ch[10] = {0}; printf("%d\n", sizeof(arr));//(1) printf("%d\n", sizeof(ch));//(3) test1(arr); test2(ch); return 0;}

Câu hỏi: Sản lượng của (1) và (2) tương ứng là bao nhiêu? (3) và (4) Sản lượng của hai nơi là bao nhiêu?

Hãy tự mình tính toán trước nhé! .

Hãy tính kết quả! .

(1)40 (2) 40 (3)10 (4) 10 。

Và kết quả chạy! .

Như bạn thấy, kết quả chạy không hề như vậy! .

Hãy cùng suy nghĩ về kết quả này Tại sao lại là kết quả 4?

Rõ ràng chúng ta đã truyền trực tiếp mảng, nhưng kích thước bộ nhớ được tính toán thông qua sizeof thì không. Có thể nào chúng ta chỉ truyền một địa chỉ?

Chúng tôi đã sửa lỗi và thấy rằng nó giống như giả định. Tham số mảng không được truyền cho toàn bộ mảng mà là một con trỏ đã được truyền! .

Trên x86, nền tảng 32 bit, không gian bộ nhớ bị con trỏ chiếm giữ là 4 byte.

++ -- 。

//Tiền tố ++ và --: #include  int main() { int a = 10; int x = ++a; // Tăng a trước rồi dùng a, đó là Giá trị của biểu thức là giá trị của a sau khi nó được tăng lên. x là 11. int y = --a; //Đầu tiên giảm a, sau đó sử dụng a, tức là giá trị của biểu thức là giá trị của a sau khi giảm. y là 10; return 0; } //Đăng ++ và -- #include  int main() { int a = 10; //Dùng a trước rồi cộng, Theo cách này , giá trị của x là 10; khi đó a trở thành 11; int y = a--; //Sử dụng a trước rồi giảm dần, do đó giá trị của y là 11;

Tóm tắt: Tiền tố++,--thực hiện thao tác tự thêm trước rồi mới sử dụng! .

Post++,--hãy sử dụng nó trước rồi thực hiện thao tác tự thêm! .

Toán tử quan hệ

> >= < <= == (xác định xem có bằng nhau không)! = (thẩm phán không bằng).

Đây là những toán tử quan hệ cơ bản! .

Chúng ta đã rất quen thuộc rồi, hãy cùng xem kết quả của toán tử quan hệ nhé! .

Có thể thấy khi kết quả phán đoán là đúng thì vs dùng 1 để biểu thị đúng và 0 để biểu thị sai.

Lưu ý: Khi kiểm tra xem các kết quả có bằng nhau hay không, chúng tôi sử dụng == thay vì toán tử gán =.

Toán tử logic

Các toán tử logic bao gồm logic AND &&, logic OR ||.

Khi chúng ta muốn kiểm tra kết quả của hai biểu thức, nếu chúng muốn được thỏa mãn cùng lúc, hãy sử dụng logic AND && Khi chỉ thỏa mãn một trong các kết quả biểu thức, hãy sử dụng logic OR ||.

Chúng ta cần phân biệt giữa toán tử logic và toán tử bitwise bitwise AND &, bitwise OR|! .

#includeint main(){ int a=3;//000000000 00000000 000000011 int b=1;//00000000 00000000 00000000 00000001 printf("%d\n",a&b); printf("%d\n",a|b); printf("%d\n",a&&b); printf("%d\n",a||b); return 0;}

Toán tử bit và toán tử logic hoàn toàn khác nhau. Một toán tử hoạt động trên số nguyên nhị phân và toán tử kia đánh giá kết quả của một biểu thức! .

&& Kết quả chỉ đúng nếu cả hai biểu thức đều đúng cùng một lúc! .

|| Kết quả chỉ sai nếu cả hai biểu thức đều sai cùng một lúc! .

Đặc điểm của biểu thức logic! .

#includeint main(){int a=3,b=5,c=6,i=0;i=a++&&++b;printf("%d %d\n",a,b);i=a++||++b;printf("%d %d\n",a,b);return 0;}

Chúng ta có thể thấy rằng biểu thức logic thứ hai OR || không được thực thi.

Tại sao lại thế này! .

Tóm tắt: Khi logic AND && được thực thi cho đến khi kết quả biểu thức sai, nó sẽ dừng thực thi biểu thức sau! .

Logic HOẶC || Khi kết quả biểu thức là đúng, việc thực thi các biểu thức sau sẽ dừng lại! .

Đây là những gì chúng ta thường gọi là đặc tính ngắn mạch logic! .

toán tử có điều kiện

exp1 ? exp2 : exp3 。

Toán tử có điều kiện thường bao gồm 3 biểu thức! Còn được gọi là (toán tử bậc ba)! .

Nếu kết quả biểu thức exp1 là đúng, exp2 sẽ được thực thi, nếu không thì exp3 sẽ được thực thi.

Bạn có thể thấy nó tương tự như câu phán đoán của chúng tôi if! .

#includeint main(){ int a=5,b=3,max=0; //Nếu câu lệnh phán đoán tìm thấy giá trị lớn nhất if(a>b) { max=a } else { max= b ; } //Biểu thức điều kiện a>b?max=a:max=b;return 0;}

Bạn có thể thấy những ưu điểm của biểu thức điều kiện, giúp đơn giản hóa mã rất nhiều! .

biểu thức dấu phẩy

exp1,exp2,exp3...expN。

Các biểu thức được phân tách bằng , là biểu thức dấu phẩy.

Đặc điểm biểu hiện.

#includeint main(){ int a=2,b=3,c=5; int i=(a++,b++,c); printf("a=%db=%dc=%di=%d",a,b,c,i);trả về 0;}

Bạn có thể thấy rằng biểu thức i=(a++,b++,c); kết quả i=5 là giá trị của biểu thức cuối cùng c.

Đặc điểm của hoạt động biểu thức dấu phẩy:

Các biểu thức được đánh giá từ trái sang phải và giá trị của biểu thức cuối cùng là giá trị của toàn bộ kết quả biểu thức dấu phẩy! .

Các nhà khai thác khác

[] Toán tử tham chiếu chỉ số dưới () toán tử gọi hàm -> Toán tử truy cập thành viên cấu trúc.

[] toán tử tham chiếu chỉ số dưới.

Toán hạng: tên mảng + giá trị chỉ mục.

int arr[10];//Tạo mảng arr[9] = 10;//Toán tử tham chiếu chỉ số thực tế. // Hai toán hạng của [] là arr và 9.

Vì có hai toán hạng nên hai toán hạng có thể hoán đổi vị trí cho nhau không?

Bạn có thể thấy arr[9] tương đương với 9[arr].

Nhưng chúng tôi không phiền khi sử dụng 9[arr].

() toán tử gọi hàm.

( ) Toán tử gọi hàm chấp nhận một hoặc nhiều toán hạng: toán hạng đầu tiên là tên hàm, các toán hạng còn lại là các tham số được truyền cho hàm.

#include  void test1() { printf("hehe\n"); } void test2(const char *str) { printf("%s\n", str } int main() { test1 ();//Thực tế () làm toán tử gọi hàm. test2("hello bit.");//Thực tế () làm toán tử gọi hàm. trả về 0 }

. :Cấu trúc.Tên thành viên->:Con trỏ cấu trúc->Tên thành viên.

#include struct Stu{ char name[10]; int age; char sex[5]; double point;}; void set_age1(struct Stu stu){ stu.age = 18;}void set_age2(struct Stu * pStu){ pStu->age = 18;//Truy cập thành viên cấu trúc}int main(){ struct Stu stu; &stu;//Truy cập thành viên cấu trúc stu.age = 20;//Truy cập thành viên cấu trúc set_age1(stu); pStu->age = 20;//Quyền truy cập thành viên cấu trúc set_age2(pStu);

  。

Tóm tắt

Bài viết này kết thúc tại đây, tôi hy vọng nó có thể hữu ích cho bạn và tôi hy vọng bạn có thể chú ý hơn đến nội dung của tôi! .

Liên kết gốc: https://blog.csdn.net/weixin_52345071/article/details/120214036.

Cuối cùng, bài viết về một bài viết sẽ giúp bạn hiểu được kiến ​​thức về các toán tử ngôn ngữ C sẽ kết thúc ở đây. Nếu bạn muốn biết thêm về một bài viết sẽ giúp bạn hiểu được kiến ​​thức về các toán tử ngôn ngữ C, vui lòng tìm kiếm bài viết CFSDN hoặc tiếp tục. Duyệt các bài viết liên quan, tôi hy vọng bạn sẽ ủng hộ blog của tôi trong tương lai! .