C语言-基础语法-01

yyl_lll

于 2024-08-17 22:17:46 发布

阅读量920

点赞数 28

文章标签： c语言开发语言

本文链接：https://blog.csdn.net/yyl_ashan/article/details/141284800

版权

1-1 程序结构

C 程序主要包括以下部分：

预处理器指令
函数
变量
语句 & 表达式
注释

#include<stdio.h>    /*预处理器指令*/ 

int main()    /*主函数*/ 
{
	
	printf("hello,world!\nhhhhhhh");  /*显示信息*/ 
	
	return 0;   /*终止main()函数并返回值0 */ 
}

1-2 基本语法

两种注释：

//单行注释
/*多
  行
  注释
*/

标识符：

C 标识符是用来标识变量、函数，或任何其他用户自定义项目的名称。

以字母或下划线_开头，且区分大小写。

关键字：

例如do、else、double、if等（不能作为常量名、变量名或其他标识符名称）。

关键字	说明
auto	声明自动变量
break	跳出当前循环
case	开关语句分支
char	声明字符型变量或函数返回值类型
const	声明只读变量
continue	结束当前循环，开始下一轮循环
default	开关语句中的"其它"分支
do	循环语句的循环体
double	声明双精度浮点型变量或函数返回值类型
else	条件语句否定分支（与 if 连用）
enum	声明枚举类型
extern	声明变量或函数是在其它文件或本文件的其他位置定义
float	声明浮点型变量或函数返回值类型
for	一种循环语句
goto	无条件跳转语句
if	条件语句
int	声明整型变量或函数
long	声明长整型变量或函数返回值类型
register	声明寄存器变量
return	子程序返回语句（可以带参数，也可不带参数）
short	声明短整型变量或函数
signed	声明有符号类型变量或函数
sizeof	计算数据类型或变量长度（即所占字节数）
static	声明静态变量
struct	声明结构体类型
switch	用于开关语句
typedef	用以给数据类型取别名
unsigned	声明无符号类型变量或函数
union	声明共用体类型
void	声明函数无返回值或无参数，声明无类型指针
volatile	说明变量在程序执行中可被隐含地改变
while	循环语句的循环条件

1-3数据类型

序号	类型与描述
1	基本类型：它们是算术类型，包括两种类型：整数类型和浮点类型。
2	枚举类型：它们也是算术类型，被用来定义在程序中只能赋予其一定的离散整数值的变量。
3	void 类型：类型说明符 void 表明没有可用的值。
4	派生类型：它们包括：指针类型、数组类型、结构类型、共用体类型和函数类型。

整数类型

类型	存储大小	值范围
char	1 字节	-128 到 127 或 0 到 255
unsigned char	1 字节	0 到 255
signed char	1 字节	-128 到 127
int	2 或 4 字节	-32,768 到 32,767 或 -2,147,483,648 到 2,147,483,647
unsigned int	2 或 4 字节	0 到 65,535 或 0 到 4,294,967,295
short	2 字节	-32,768 到 32,767
unsigned short	2 字节	0 到 65,535
long	4 字节	-2,147,483,648 到 2,147,483,647
unsigned long	4 字节	0 到 4,294,967,295

sizeof(type)运算符：

得到对象或类型的存储字节大小。

#include <stdio.h>
#include <limits.h>

int main()
{
                         //获取int类型的大小
   printf("int 存储大小 : %lu \n", sizeof(int));
                //其中%lu是32位无符号整数

   return 0;
}

结果为：

int 存储大小 : 4

浮点类型

类型	存储大小	值范围	精度
float	4 字节	1.2E-38 到 3.4E+38	6 位小数
double	8 字节	2.3E-308 到 1.7E+308	15 位小数
long double	16 字节	3.4E-4932 到 1.1E+4932	19 位小数

举例：

#include <stdio.h>
#include <float.h>

int main()
{
   printf("float 存储最大字节数 : %lu \n", sizeof(float));
   printf("float 最小值: %E\n", FLT_MIN );
   printf("float 最大值: %E\n", FLT_MAX );
               //%E 为以指数形式输出单、双精度实数
   printf("精度值: %d\n", FLT_DIG );

   return 0;
}

结果为：

float 存储最大字节数 : 4 
float 最小值: 1.175494E-38
float 最大值: 3.402823E+38
精度值: 6

void 类型

void类型指定没有可用的值。

序号	类型与描述
1	函数返回为空 C 中有各种函数都不返回值，或者您可以说它们返回空。不返回值的函数的返回类型为空。例如 void exit (int status);
2	函数参数为空 C 中有各种函数不接受任何参数。不带参数的函数可以接受一个 void。例如 int rand(void);
3	指针指向 void 类型为 void * 的指针代表对象的地址，而不是类型。例如，内存分配函数 *void malloc( size_t size );** 返回指向 void 的指针，可以转换为任何数据类型。

1-4 变量

每个变量都有特定的类型，而类型决定了变量存储的大小和布局，运算符可应用在变量上。

类型	描述
char	通常是一个字节（八位）。这是一个整数类型。
int	对机器而言，整数的最自然的大小。
float	单精度浮点值。单精度是这样的格式，1位符号，8位指数，23位小数。
double	双精度浮点值。双精度是1位符号，11位指数，52位小数。
void	表示类型的缺失。

C 语言也允许定义各种其他类型的变量，比如枚举、指针、数组、结构、共用体等等。

1-4-1 变量定义

变量定义就是告诉编译器在何处创建变量的存储，以及如何创建变量的存储。

变量定义指定一个数据类型，并包含了该类型的一个或多个变量的列表。例：

int    i, j, k;
char   c, ch;
float  f, salary;
double d;

变量可以在声明的时候被初始化（指定一个初始值）。例：

extern int d = 3, f = 5;    // d 和 f 的声明与初始化
int d = 3, f = 5;           // 定义并初始化 d 和 f
byte z = 22;                // 定义并初始化 z
char x = 'x';               // 变量 x 的值为 'x'

不带初始化的定义：带有静态存储持续时间的变量会被隐式初始化为 NULL（所有字节的值都是 0），其他所有变量的初始值是未定义的。

1-4-2 变量声明

变量声明向编译器保证变量以指定的类型和名称存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。变量声明只在编译时有它的意义，在程序连接时编译器需要实际的变量声明。

变量的声明有两种情况：

1、一种是需要建立存储空间的。例如：int a 在声明的时候就已经建立了存储空间。
2、另一种是不需要建立存储空间的，通过使用extern关键字声明变量名而不定义它。例如：extern int a 其中变量 a 可以在别的文件中定义的。

除非有extern关键字，否则都是变量的定义：

extern int i; //声明，不是定义
int i; //声明，也是定义

实例1：

其中，变量在头部就已经被声明，但是定义与初始化在主函数内：

#include <stdio.h>

// 函数外定义变量 x 和 y
int x;
int y;
int addtwonum()
{
    // 函数内声明变量 x 和 y 为外部变量
    extern int x;
    extern int y;
    // 给外部变量（全局变量）x 和 y 赋值
    x = 1;
    y = 2;
    return x+y;
}

int main()
{
    int result;
    // 调用函数 addtwonum
    result = addtwonum();

    printf("result 为: %d",result);
    return 0;
}

以上代码运行后结果：

result 为: 3

同样的，如果需要在一个源文件中引用另外一个源文件中定义的变量，我们只需在引用的文件中将变量加上 extern 关键字的声明即可。实例2：

addtwonum.c 文件代码：

#include <stdio.h>
/*外部变量声明*/
extern int x ;
extern int y ;
int addtwonum()
{
    return x+y;
}

test.c 文件代码：

#include <stdio.h>

/*定义两个全局变量*/
int x=1;
int y=2;
int addtwonum();

int main(void)
{
    int result;
    result = addtwonum();
    printf("result 为: %d\n",result);
    return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

result 为: 3

1-4-3 左值(Lvalues)和右值(Rvalues)

左值（lvalue）：指向内存位置的表达式被称为左值（lvalue）表达式。左值可以出现在赋值号的左边或右边。
右值（rvalue）：术语右值（rvalue）指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式，也就是说，右值可以出现在赋值号的右边，但不能出现在赋值号的左边。

例如，变量是左值，可以出现在赋值号的左或右边。而数值型的固定值是右值，不能被赋值，所以不能出现在赋值号的左边。

有效语句例子：

int n = 20;

无效语句例子：

10 = 20;

1-5 常量

常量是固定值，在程序执行期间不会改变。这些固定的值，又叫做字面量。

常量可以是任何的基本数据类型，比如整数常量、浮点常量、字符常量，或字符串字面值，也有枚举常量。

1-5-1 整数常量

整数常量可以是十进制、八进制或十六进制的常量，可带前缀和后缀。

前缀：0X或0x表示十六进制，0表示八进制。不带前缀的默认十进制。

后缀：U表示无符号整数(unsigned),L表示长整数(long)。后缀不分大小写，U和L 的顺序任意。

以下是各种类型的整数常量的实例：

85         /* 十进制 */
0213       /* 八进制 */
0x4b       /* 十六进制 */
30         /* 整数 */
30u        /* 无符号整数 */
30l        /* 长整数 */
30ul       /* 无符号长整数 */

列举几个实例：

212         /* 合法的 */
215u        /* 合法的 */
0xFeeL      /* 合法的 */
078         /* 非法的：8 不是八进制的数字 */
032UU       /* 非法的：不能重复后缀 */

1-5-2 浮点常量

浮点常量(f)由整数部分、小数点、小数部分和指数部分组成。可以使用小数形式或者指数形式来表示浮点常量。带符号的指数是用 e 或 E 引入的。

当使用小数形式表示时，必须包含整数部分、小数部分，或同时包含两者。当使用指数形式表示时，必须包含小数点、指数，或同时包含两者。

列举几个实例：

3.14159       /* 合法的 */
314159E-5L    /* 合法的 */
/*
  314159表示基数，即3.14159
  E-5表示指数，即10的负5次方，即0.00001
  L表示该数值是一个长整型(long)
*/

510E          /* 非法的：不完整的指数 */
210f          /* 非法的：没有小数或指数 */
.e55          /* 非法的：缺少整数或分数 */

1-5-3 字符常量

字符常量是括在单引号中，例如，'x'可以存储在char类型的简单变量中。

字符常量可以是一个普通的字符（例如 'x'）、一个转义序列（例如 '\t'），或一个通用的字符（例如 '\u02C0'）。

在 C 中，有一些特定的字符，当它们前面有反斜杠时，它们就具有特殊的含义，被用来表示如换行符（\n）或制表符（\t）等。下表列出了一些这样的转义序列码：

转义序列	含义
\	\ 字符
'	' 字符
"	" 字符
?	? 字符
\a	警报铃声
\b	退格键
\f	换页符
\n	换行符，跳到下一行
\r	回车，操作在当前行
\t	空4个字符，相当于一个Tab键
\v	垂直制表符
\ooo	一到三位的八进制数
\xhh . . .	一个或多个数字的十六进制数

1-5-4 字符串常量

字符串字面值或常量是括在双引号 "" 中的。一个字符串包含类似于字符常量的字符：普通的字符、转义序列和通用的字符。

"hello, dear"

"hello, " "d" "ear"

1-5-5 定义常量

在 C 中，有两种简单的定义常量的方式：

使用 #define 预处理器。
使用 const 关键字。

① #define 预处理器

使用 #define 预处理器定义常量的形式：

#define identifier value

实例：

#include <stdio.h>

#define LENGTH 10   
#define WIDTH  5
#define NEWLINE '\n'

int main()
{

   int area;  

   area = LENGTH * WIDTH;
   printf("value of area : %d", area);
   printf("%c", NEWLINE);

   return 0;
}

以上代码编译后结果为：

value of area : 50

② const 关键字

使用 const 前缀声明指定类型的常量的形式：

const type variable = value;

实例：

#include <stdio.h>

int main()
{
   const int  LENGTH = 10;
   const int  WIDTH  = 5;
   const char NEWLINE = '\n';
   int area;  

   area = LENGTH * WIDTH;
   printf("value of area : %d", area);
   printf("%c", NEWLINE);

   return 0;
}

以上代码编译后结果为：

value of area : 50

请注意，把常量定义为大写字母形式。

1-6 存储类

存储类定义了C程序中变量或函数的范围和生命周期。这些说明符放置在它们所修饰的类型之前。

下面列出 C 程序中可用的存储类：

自动存储类auto：默认的存储类，声明的变量将在栈上分配内存，生命周期与变量相同。
寄存器存储类register：声明的变量将被存放在寄存器中，生命周期与变量相同。
静态存储类static：声明的变量只分配一次内存，在程序的整个运行期间都存在，直到程序结束。
外部存储类extern：声明的变量要在其他文件中定义，在本文件中只声明，不分配内存。

1-6-1 auto 存储类（自动存储类）

auto存储类是所有局部变量默认的存储类，也称为局部变量。在函数内部定义的变量默认为auto存储类别。auto变量的生命周期与其所在的函数相同。

自动存储类的变量会在函数调用时被自动分配内存，在函数结束时自动释放内存。当函数执行完毕时，auto变量就会被销毁。

{
   int mount;
   auto int month;
   //放在函数内时，都是局部变量，第一个与第二个作用一样
}

上面的实例定义了两个带有相同存储类的变量，auto 只能用在函数内，即 auto 只能修饰局部变量。

示例代码：

#include <stdio.h>
void func()
{
    auto int i = 0; // 定义自动存储类变量
    i++; // 对变量进行操作
    printf("i = %d\n", i);
}
int main()
{
    func();
    func();//重复调用，func里面i变量也会重新运行初始化
    return 0;
}

输出：

i = 1

i = 1

1-6-2 register存储类（寄存器存储类）

register存储类用于定义存储在寄存器中，而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 '&' 运算符（因为它没有内存位置）。

{
   register int  miles;
}

寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 'register' 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。

1-6-3 static存储类

static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。修饰局部变量时，函数只初始化一次变量，再次调用变量所在的函数也不会再次初始化。

static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。

全局声明的一个 static 变量或方法可以被任何函数或方法调用，只要这些方法出现在跟 static 变量或方法同一个文件中。

以下实例演示了 static 修饰全局变量和局部变量的应用：

#include <stdio.h>

/* 函数声明 */
void func1(void);

static int count=10;        /* 全局变量！！ - static 是默认的 */

int main()
{
  while (count--) {
      func1();
  }
  return 0;
}

void func1(void)
{
/* 'thingy' 是 'func1' 的局部变量 - 只初始化一次
 * 每次调用函数 'func1'时， 'thingy' 值不会被重置！
 */                
  static int thingy=5;  //main再次调用func，也不会再次初始化thingy
  thingy++;
  printf(" thingy 为 %d ， count 为 %d\n", thingy, count);
}

当上面的代码被编译和执行时，它会产生下列结果：

 thingy 为 6 ， count 为 9
 thingy 为 7 ， count 为 8
 thingy 为 8 ， count 为 7
 thingy 为 9 ， count 为 6
 thingy 为 10 ， count 为 5
 thingy 为 11 ， count 为 4
 thingy 为 12 ， count 为 3
 thingy 为 13 ， count 为 2
 thingy 为 14 ， count 为 1
 thingy 为 15 ， count 为 0

1-6-4 extern存储类

extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 extern 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。

当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解，extern 是用来在另一个文件中声明一个全局变量或函数。

extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候，如下所示：

第一个文件：main.c

#include <stdio.h>

int count ;    //该文件中的count---定义并声明
extern void write_extern();

int main()
{
   count = 5;  
   write_extern();
}

第二个文件：support.c

#include <stdio.h>

extern int count;   //声明（引用），没有在该文件中定义

void write_extern(void)
{
   printf("count is %d\n", count);
}

在这里，第二个文件中的 extern 关键字用于声明已经在第一个文件 main.c 中定义的 count。运行结果为：

count is 5

yyl_lll

关注

28
点赞
踩
13

收藏

觉得还不错? 一键收藏
1
评论
C语言-基础语法-01

变量定义就是告诉编译器在何处创建变量的存储，以及如何创建变量的存储。变量定义指定一个数据类型，并包含了该类型的一个或多个变量的列表。char c, ch;double d;变量可以在声明的时候被初始化（指定一个初始值）。// d 和 f 的声明与初始化// 定义并初始化 d 和 f// 定义并初始化 z// 变量 x 的值为 'x'不带初始化的定义：带有静态存储持续时间的变量会被隐式初始化为 NULL（所有字节的值都是 0），其他所有变量的初始值是未定义的。使用#define预处理器。
复制链接

扫一扫