詳解C語言中的函數、數組與指針

1、函數：當程序很小的時候，我們可以使用一個main函數就能搞定，但當程序變大的時候，就超出了人的大腦承受范圍，邏輯不清了，這時候就需要把一個大程序分成許多小的模塊來組織，于是就出現了函數概念；

　　　　  函數是C語言代碼的基本組成部分，它是一個小的模塊，整個程序由很多個功能獨立的模塊（函數）組成。這就是程序設計的基本分化方法；

　　(1) 寫一個函數的關鍵：

　　　　函數定義：函數的定義是這個函數的實現，函數定義中包含了函數體，函數體中的代碼段決定了這個函數的功能；

　　　　函數聲明：函數聲明也稱函數原型聲明，函數的原型包含三部分：函數名，返回值類型，函數參數列表，函數的聲明是告訴使用函數的人，這個函數使用時應該傳遞給他什么樣的參數，

　　　　　　　　　它會返回什么樣類型的返回值。這些東西都是寫函數的人在函數定義中規定好的，如果使用函數的人不參照這個原型來使用，就會出錯，結果就會和你想的不一樣；

　　　　函數調用：函數調用就是使用函數名來調用函數完成功能。調用時必須參照原型給函數傳參，然后從函數得到適當的返回值作為結果；

　　(2) 函數的參數：函數調用的過程，其實就是實參傳遞給形參的一個過程。這個傳遞像是一次拷貝，實參（本質是一個變量）本身并沒有進入到函數內，而是把自己的值復制了一份傳給了函數中的形參，

　　　　　　　　　　在函數中參與運算，這種傳參方法，就叫做傳值調用；

　　　　形參：形式參數，在函數定義和函數聲明中的參數列表中的參數都是形參；

　　　　實參：實際參數，函數調用中，實際傳遞的參數才是實參。

　　(3) 返回值(關鍵字return)：當函數執行完之后，會給調用該函數的地方返回一個值。這個值的類型就是函數聲明中返回值類型，這個值就是函數體中最后一句return xxx;返回的那個值；

　　(4) 函數名：取函數名要注意以下幾點：

　　　　第一，起名字時候不能隨意，要符合規則，而這個規則分別有兩個層次，即第一層是合法，第二層是合理。合法就是符號C語言中變量名的命名規則，合理就是變量名起的好，

　　　　　　　　人一看就知道什么意思，一看就知道這個函數是干嘛的；

　　　　第二，C語言中，所有的符號都是區分大小寫的；

　　　　第三，C語言函數名的命名習慣。這個沒有固定的結論，有多種使用都很廣泛的命名方式如下：

　　　　　　　　linux的命名習慣：student_age　　str_to_int

　　　　　　　　駱駝命名法：studentAge　　strToInt

　　　　注：想進一步了解可以參考林銳的《高質量程序設計指南》；

// 簡單計算器
#include <stdio.h>
int add(int a, int b);
int sub(int a, int b);
int mul(int a, int b);
int div(int a, int b);
int main(void)
{
  int a, b, c;
  a = 54;
  b = 32;
  c = add(a, b);
  //c = sub(a, b);
  //c = mul(a, b);
  //c = div(a, b);
  printf("c = %d.\n", c);
  printf("a - b = %d.\n", sub(a, b));
  return 0;
}
int add(int a, int b)
{
  return a + b;
}
int sub(int a, int b)
{
  return a - b;
}
int mul(int a, int b)
{
  return a * b;
}
int div(int a, int b)
{
  return a / b;
}

2、數組：數組就是若干個數組成的一個組，數就是一個特定數據類型的變量，組就是說好多數放在了一起；

　　(1) 數組的定義：

　　　　int a[10]; 　　數組中元素類型 數組名[數組元素個數];

　　　　注：數組中的所有元素都是同一種數據類型，不可能在一個數組中出現兩種數據類型的數。

　　(2) 數組的使用：數組定義的時候是作為一個整體來定義的，但是使用的時候不能作為一個整體來使用，使用時必須拆開使用數組中的各個元素；

　　　　如：數組int a[10]，使用其中的十個元素，分別用a[0]……a[9]，其中[]是數組的標志，[]中的數字叫做數組的下標(index，索引)，下標是我們訪問數組中各個元素的指引，

　　　　　　下標是0代表數組中第一個元素，下標是1代表數組第二個元素，以此類推，若數組長度為n，則下標中最后一個是n-1；

　　　　注：訪問數組時要特別注意下標，下標是從0開始的，如果下標超出了n-1，會產生越界訪問，結果是不可預期的；

　　(3) 數組的初始化：初始化是為了讓對象有一個預定的初始狀態，數組的初始化分兩種：

　　　　第一種：完全初始化。依次賦值；

　　　　第二種：不完全初始化。初始化式中的值從a[0]開始，依次向后賦值，不足的默認用0填充賦值

　　(4) 不同數據類型的數組：　

　int a[3];　　　　　　// 整型數組
　　　　float b[3];　　　　　// 單精度浮點型數組
　　　　double c[3];　　　　// 雙精度浮點型數組
　　　　char d[3];　　　　　// 字符型數組

　　(5) 字符數組：在C語言中引用一個單個字符時，應該用單引號''括起來，譬如'a'；

　　　　字符數組的初始化：定義數組同時初始化，則可以省略數組定義時[]中的長度。C語言編譯器會自動推論其長度，推論依據是初始化式中初始化元素的個數；

　　　　引用字符串：在C語言中引用一個字符串時，應該用""括起來，如"abcde"，其中"abcde"實際上有6個字符，分別是'a' 'b' 'c' 'd' 'e' '\0'；

　　　　　　　　　　'\0' 是C語言中定義的字符串的結尾標志，這個字符是ASCII碼表中的第一個字符，它的編碼值是0，對應的字符是空字符(不可見字符)；

// 數組的演示
#include <stdio.h>
int main(void)
{
  int a[4];
  a[0] = 23;
  a[1] = 54;
  a[2] = 98;
  a[3] = 74;
  printf("a[1] = %d, a[3]= %d.\n", a[1], a[3]);
  return 0;
}

// 字符數組的演示
#include <stdio.h>
int main(void)
{
/*
  int i = 0;
  //char a[5];
  //char a[5] = {'a', 'b', 'c', 'd', 'e'};
  //char a[5] = {97, 98, 99, 100, 101};
  //char a[] = {97, 98, 99, 100, 101};
  char a[] = "abcde";
  for (i=0; i<5; i++)
  {
    printf("a[%d] = %d  %c\n", i, a[i], a[i]);
  }
*/
  int i = 0;
  char a[] = {97, 98, 99, 100, 101};
  char b[] = "abcde";
  printf("sizeof(a) = %d, sizeof(b) = %d.\n", sizeof(a), sizeof(b));
  return 0;
}

3、指針：全稱是指針變量，其實質是C語言的一種變量。這種變量比較特殊，通常它的值會被賦值為某個變量的地址值(p = &a)，然后我們可以使用*p這樣的方式去間接訪問p所指向的那個變量；

　　(1) 指針存在的意義：可以間接訪問。有了指針之后，我們訪問變量a不必只通過a這個變量名來訪問。而可以通過p = &a; *p = xxx;這樣的方式來間接訪問變量a；

　　(2) 兩個重要的運算符：&和*

　　　　&：取地址符，將它加在某個變量前面，則組合后的符號代表這個變量的地址值；

　　　　如： int a; int *p; p = &a; 則將變量a的地址值賦值給p

　　　　　　a　　　　  代表變量a本身

　　　　　　p　　　　  代表指針變量p本身

　　　　　　&a　　　　代表變量a的地址值

　　　　　　*p　　　　代表指針變量p所指向的那個變量，也就是變量a

　　　　　　&p　　　　代表指針變量p本身的地址值，符號雖合法，但對題目無意義

　　　　　　*a　　　　把a看作一個指針，*a表示這個指針所指向的變量，該符號不合法

　　　　*：指針符號。指針符號在指針定義和指針操作的時候，解析方法是不同的；

　　　　　　int *p; 定義指針變量p，這里的*p含義不是代表指針變量p所指向的那個變量，在定義時這里的*含義是告訴編譯器p是一個指針

　　　　　　*p = 0x24; 使用指針的時候，*p則代表指針變量p所指向的那個變量

　　(3) 指針的定義和初始化：

　　　　第一種：先定義再賦值

　　　　　　　　int *p;　　　　// 定義指針變量p

　　　　　　　　p = &a;　　　　// 給p賦值

　　　　第二種：定義的同時初始化

　　　　　　　　int *p = &a;　　// 效果等同于上面的兩句

　　(4) 各種不同類型的指針：指針變量本質上是一個變量，指針變量的類型屬于指針類型。int *p;定義了一個指針類型的變量p，這個p所指向的那個變量是int型；

　　　　int *pInt;　　　　　　// pInt是指針變量，指向的變量是int類型

　　　　char *pChar;　　　　// pChar是指針類型，指向的變量是char類型

　　　　float *pFloat;

　　　　double *pDouble;

　　　　注：各種指針類型和它們所指向的變量類型必須匹配，否則結果不可預知；

　　(5) 指針定義的兩種理解方法：

　　　　int *p;

　　　　第一種(推薦)：首先看到p，這個是變量名；其次，p前面有個*，說明這個變量p是一個指針變量；最后，*p前面有一個int，說明這個指針變量p所指向的是一個int型數據；

　　　　第二種：首先看到p，這個是變量名；其次，看到p前面的int *，把int *作為一個整體來理解，int *是一種類型(復合類型)，該類型表示一種指向int型數據的指針；

　　(6) 指針與數組的初步結合：

　　　　數組名：做右值時，數組名表示數組的首元素首地址，因此可以直接賦值給指針；

　　　　如：int a[10];其中a和&a[0]都表示數組首元素a[0]的首地址，而&a則表示數組的首地址；

　　　　注：數組首元素的首地址和數組的首地址是不同的，前者是數組元素的地址，而后者是數組整體的地址。兩個東西的含義不同，但是數值上是相同的；

　　　　根據以上，我們知道可以用一個指針指向數組的第一個元素，這樣就可以用間接訪問的方式去逐個訪問數組中的元素，這樣訪問數組就有了兩種方式：

　　　　有 int a[5];  int *p; p = a;

　　　　數組的方式依次訪問：a[0]　　a[1]　　a[2]　　a[3]　　a[4]

　　　　指針的方式依次訪問：*p　　*(p+1)　　*(p+2)　　*(p+3)　　*(p+4)

　　(7) 指針與++ --符號進行運算：指針本身也是一種變量，因此也可以進行運算，但是因為指針變量本身存的是某個其他變量的地址值，因此該值進行* / %等運算是無意義的，

　　　　　　　　　　　　　　　　　故兩個指針變量相加本身也無意義，但相減有意義。指針變量+1，-1是有意義的，+1就代表指針所指向的格子向后挪一格，-1代表指針所指向的格子向前挪一格。

　　　　*p++的解析：++先跟p結合，但是因為++后置的時候，本身含義就是先運算后增加1(運算指的是p++整體與前面的*進行運算；增加1指的是p+1)，所以實際上*p++符號整體對外表現的

　　　　　　　　　　　　值是*p的值，運算完成后p再加1；

　　　　*p++等同于：*p;   p += 1;

　　　　*++p等同于：p += 1; *p;

　　　　(*p)++，使用()強制將*與p結合，只能先計算*p，然后對*p整體的值++

　　　　++(*p)，先*p取值，再前置++，該值+1后作為整個表達式的值

// 指針的定義、賦值及初始化
#include <stdio.h>
int main(void)
{
  int a = 23;
  int *p = &a;
  *p = 111;
  printf("a = %d\n", a);
  return 0;
}

// 用指針去訪問數組
#include <stdio.h>
int main(void)
{
  int a[5] = {555, 444, 333, 222, 111};
  int *p;
  //p = &a;
  //p = &a[0];
  p = a;
  //p += 1;
  //printf("*p = %d.\n", *p);
  //printf("*p++ = %d.\n", *p++);
  //printf("*++p = %d.\n", *++p);
  //printf("(*p)++ = %d.\n", (*p)++);
  printf("++(*p) = %d.\n", ++(*p));
  return 0;
}

4、補充：變量與數據類型的實質

　　(1) 程序在環境中運行時，需要一定的資源支持，而這些資源包括：CPU(運算能力)、內存等，這些資源一般由運行時環境（一般是操作系統）來提供，比如我們在linux系統上./a.out運行程序時，

　　　　linux系統為我們提供了運算能力和內存；

　　(2) 程序越龐大，運行時消耗的資源越多，比如說內存額定占用，如果越大的程序，占用的內存肯定越多，而占用內存的其中之一，就是我們在程序中定義的變量；

　　(3) C語言程序中，變量的實質就是內存中的一個格子。當我們定義了一個變量后，就相當于在內存中得到了一個格子，而這個格子的名字就是變量名，

　　　　以后訪問這個內存格子就只用使用該變量名就行了，這就是變量的本質；

　　(4) 數據類型的實質是內存中格子的不同種類。比如在32位的機器上：

　　　　短整形格子(short)　　　　　　　　　　占用2字節，即16位的空間

　　　　整形格子(int)　　　　　　　　　　　　 占用4字節，即32位的空間

　　　　單精度浮點型格子(float)　　　　　　　  占用4字節，即32位的空間

　　　　雙精度浮點型格子(double)　　　　　　  占用8字節，即64位的空間

　　　　字符型格子(char)　　　　　　　　　　　占用1字節，即8位的空間

　　(5) sizeof運算符：返回一個變量或者一個數據類型的內存占用長度，以字節為單位；

// sizeof運算符的演示
#include <stdio.h>
int main(void)
{
  int len;
  //len = sizeof(int);
  //len = sizeof(float);
  //len = sizeof(double);
  //len = sizeof(char);
  //double d;
  //len = sizeof(d);
  int a[5];
  //len = sizeof(a);
  len = sizeof(a) / sizeof(a[0]);
  printf("len = %d.\n", len);
  return 0;
}

以上所述是小編給大家介紹的C語言中的函數、數組與指針，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對億速云網站的支持！