5分钟快速入门C语言的基本用法

欢迎关注微信公众号“Python小灶，和我一起每天学习Python新知识”

C语言的基本用法

1、程序框架

#include 
 
int main()
{
    
    return 0;
}

2、输入输出

#include 
 
int main()
{
    int n = 0;
    scanf("%d", &n); // 遇到空格停止输入
    printf("n:%d", n);
    return 0;
}

2.1、输入输出拓展

// getchar() & putchar() 函数 单个字符输入输出
#include 
 
int main( )
{
   int c;
   printf( "Enter a value :");
   c = getchar( );
 
   printf( "\nYou entered: ");
   putchar( c );
   printf( "\n");
   return 0;
}

// gets() & puts() 函数 字符串输入输出
#include 
 
int main( )
{
   char str[100];
 
   printf( "Enter a value :");
   gets( str );
 
   printf( "\nYou entered: ");
   puts( str );
   return 0;
}

3、数据类型

// 整数  
int a;
printf("%d",...)
scanf("%d",...)
// 小数
double b;  // 双精度double用lf,单精度float用f
printf("%f",...)
scanf("%lf",...)
// 字符 单引号
char c;
printf("%c",...)
scanf("%c",...)
// 地址
printf("%p",...) 

4、判断和循环

// 判断
if ( <判断条件> ) {
    <循环体语句>;
} else if (<判断条件>) {
    <循环体语句>;
} else {
    <循环体语句>;
}

// 循环1
while (<循环条件>){
    <循环体语句>	;
}

// 循环2
do {
    <循环体语句>;
}while(<循环条件>)；

// 循环3
for (int i=0; i<5; i++){
	<循环体语句>;
}

//switch-case 遇到break停止
switch (控制表达式) {
case 常量1：
	语句；
case 常量2：
	语句；
	break;
case 常量3：
	语句；
...
default:
	语句；
}

5、数组与函数

// 数组定义
int number[100];
double number[20];
// 数组的初始化
int a[] = {1, 2, 3, 4, 5};
int a[10] = {0};
// 二维数组
int a[3][5];

// 函数的定义与使用
void sum(int begin, int end) //函数头（void:返回类型，sum:函数名，（）：参数表）
{
    int i;                   //函数体
    int sum = 0;
    for (i=begin; i<=end; i++){
        sum += i;
    }
}
// 函数调用
函数名（参数）;
// 函数原型声明
函数头 + ； 放在前面

5.1、传递数组给函数

// 必须以下面三种方式来声明函数形式参数，实际上，传递的都是指针
void myFunction(int *param) // 形式参数是一个指针
void myFunction(int param[10]) // 形式参数是一个已定义大小的数组
void myFunction(int param[]) // 形式参数是一个已定义大小的数组
{
}


//应用
#include 
 
/* 函数声明 */
double getAverage(int arr[], int size);
 
int main ()
{
   /* 带有 5 个元素的整型数组 */
   int balance[5] = {1000, 2, 3, 17, 50};
   double avg;
 
   /* 传递一个指向数组的指针作为参数 */
   avg = getAverage( balance, 5 ) ;
 
   /* 输出返回值 */
   printf( "平均值是： %f ", avg );
    
   return 0;
}
 

5.2、从函数返回数组

#include 
#include 
#include 
 
/* 要生成和返回随机数的函数 */
int * getRandom( )
{
  static int  r[10];
  int i;
 
  /* 设置种子 */
  srand( (unsigned)time( NULL ) );
  for ( i = 0; i < 10; ++i)
  {
     r[i] = rand();
     printf( "r[%d] = %d\n", i, r[i]);
 
  }
 
  return r;
}
 
/* 要调用上面定义函数的主函数 */
int main ()
{
   /* 一个指向整数的指针 */
   int *p;
   int i;
 
   p = getRandom();
   for ( i = 0; i < 10; i++ )
   {
       printf( "*(p + %d) : %d\n", i, *(p + i));
   }
 
   return 0;
}

5.3、指向数组的指针

double balance[50];
/*balance 是一个指向 &balance[0] 的指针，即数组 balance 的第一个元素的地址。
因此，下面的程序片段把 p 赋值为 balance 的第一个元素的地址：*/

double *p;
double balance[10];

p = balance;

5.4、指向函数的指针

#include 
 
int max(int x, int y)
{
    return x > y ? x : y;
}
 
int main(void)
{
    /* p 是函数指针 */
    int (* p)(int, int) = & max; // &可以省略
    int a, b, c, d;
 
    printf("请输入三个数字:");
    scanf("%d %d %d", & a, & b, & c);
 
    /* 与直接调用函数等价，d = max(max(a, b), c) */
    d = p(p(a, b), c); 
 
    printf("最大的数字是: %d\n", d);
 
    return 0;
}

5.5、回调函数

// 函数指针变量可以作为某个函数的参数来使用的，回调函数就是一个通过函数指针调用的函数。

// 简单讲：回调函数是由别人的函数执行时调用你实现的函数。
#include   
#include 
 
// 回调函数
void populate_array(int *array, size_t arraySize, int (*getNextValue)(void))
{
    for (size_t i=0; i<arraySize; i++)
        array[i] = getNextValue();
}
 
// 获取随机值
int getNextRandomValue(void)
{
    return rand();
}
 
int main(void)
{
    int myarray[10];
    /* getNextRandomValue 不能加括号，否则无法编译，因为加上括号之后相当于传入此参数时传入了 int , 而不是函数指针*/
    populate_array(myarray, 10, getNextRandomValue);
    for(int i = 0; i < 10; i++) {
        printf("%d ", myarray[i]);
    }
    printf("\n");
    return 0;
}

6、数组运算

// 数组的大小
int a[] = {1, 2, 3, 4, 5};
sizeof(a)/sizeof(a[0])
// 数组的赋值
遍历，不能直接赋值

7、指针和字符串

// 运算符& --> 取变量的地址
// 运算符* --> 取地址的值
// 指针就是保存地址的变量
// 函数参数表中的数组实际上就是指针， sizeof(a) == sizeof(int*)，数组变量是特殊的指针
// 数组变量是const的指针，所以不能被赋值
int i;
int *p = &i; // p保存的是地址
// 例子1
void f(int *p);

int main(void)
{
    int i = 6;
    printf("&i=%p\n", &i);
    f(&i);
    
    return 0;
}

void f(int *p)
{
    printf("p=%p\n", p);
}

// 字符数组
char word[] = {'h', 'e', 'l', 'l', 'o'};
// 字符串, 以字符数组的形式存在，string.h
char word[] = {'h', 'e', 'l', 'l', 'o', '\0'};
// 定义
char *str = "Hello";   // 不知道在哪，不可修改-->处理字符串
char word[] = "Hello"; //这个字符串就在这，可以修改-->构造字符串
char line[10] = "Hello";
// 常用函数
string.h
1	strcpy(s1, s2);
复制字符串 s2 到字符串 s1。
2	strcat(s1, s2);
连接字符串 s2 到字符串 s1 的末尾。
3	strlen(s1);
返回字符串 s1 的长度。
4	strcmp(s1, s2);
如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回小于 0；如果 s1>s2 则返回大于 0。
5	strchr(s1, ch);
返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。
6	strstr(s1, s2);
返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。

8、指针和字符串1

const  修饰符，加在变量前，代表变量不可修改
int i;
const int* p1 = &i;
int const* p2 = &i;
int *const p3 = &i; // 指针不能被修改
// 判断哪个被const的标志是const在*的前面还是后面

int a[] = {1, 2, 3};
int *p = a;
*(p + n) <--> a[n]

*p++ 取出p所指的值，然后把p移到下一个位置
申请内存 malloc()
释放内从 free()
    
// 指向整数的指针数组的声明
int *ptr[MAX];
// 指向字符的指针数组
const char *names[] = {
                   "Zara Ali",
                   "Hina Ali",
                   "Nuha Ali",
                   "Sara Ali",
   };

// 指向指针的指针
int **var;
    
// 字符串操作
#include 

int main(int argc, char const *argv[])
{
    int ch;
    while ( (ch = getchar()) != EOF ){
        putchar(ch)
    }
    printf("EOF\n")
}

9、枚举

#include 
 
enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
};
 
int main()
{
    enum DAY day;
    day = WED;
    printf("%d",day);
    return 0;
}

10、结构体

//结构作为函数参数
#include 
#include 
 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};
 
/* 函数声明 */
void printBook( struct Books book );
int main( )
{
   struct Books Book1;        /* 声明 Book1，类型为 Books */
   struct Books Book2;        /* 声明 Book2，类型为 Books */
 
   /* Book1 详述 */
   strcpy( Book1.title, "C Programming");
   strcpy( Book1.author, "Nuha Ali"); 
   strcpy( Book1.subject, "C Programming Tutorial");
   Book1.book_id = 6495407;
 
   /* Book2 详述 */
   strcpy( Book2.title, "Telecom Billing");
   strcpy( Book2.author, "Zara Ali");
   strcpy( Book2.subject, "Telecom Billing Tutorial");
   Book2.book_id = 6495700;
 
   /* 输出 Book1 信息 */
   printBook( Book1 );
 
   /* 输出 Book2 信息 */
   printBook( Book2 );
 
   return 0;
}
void printBook( struct Books book )
{
   printf( "Book title : %s\n", book.title);
   printf( "Book author : %s\n", book.author);
   printf( "Book subject : %s\n", book.subject);
   printf( "Book book_id : %d\n", book.book_id);
}

//指向结构的指针
  /* 通过传 Book1 的地址来输出 Book1 信息 */
  printBook( &Book1 );
  
  /* 通过传 Book2 的地址来输出 Book2 信息 */
  printBook( &Book2 );
 
  return 0;
}
void printBook( struct Books *book )
{
   printf( "Book title : %s\n", book->title);
   printf( "Book author : %s\n", book->author);
   printf( "Book subject : %s\n", book->subject);
   printf( "Book book_id : %d\n", book->book_id);
}

9、共用体

// 共用体是一种特殊的数据类型，允许您在相同的内存位置存储不同的数据类型。
#include 
#include 
 
union Data
{
   int i;
   float f;
   char  str[20];
};
 
int main( )
{
   union Data data;        
 
   data.i = 10;
   printf( "data.i : %d\n", data.i);
   
   data.f = 220.5;
   printf( "data.f : %f\n", data.f);
   
   strcpy( data.str, "C Programming");
   printf( "data.str : %s\n", data.str);
 
   return 0;
}
// 在这里，所有的成员都能完好输出，因为同一时间只用到一个成员。

9、宏

// 预定义宏
#include 

main()
{
   printf("File :%s\n", __FILE__ );
   printf("Date :%s\n", __DATE__ );
   printf("Time :%s\n", __TIME__ );
   printf("Line :%d\n", __LINE__ );
   printf("ANSI :%d\n", __STDC__ );

}
// 参数化的宏
#include 

#define square(x) ((x) * (x))
#define MAX(x,y) ((x) > (y) ? (x) : (y))