精华内容
下载资源
问答
  • 主要介绍了C语言头文件定义const变量详解的相关资料,需要的朋友可以参考下
  • C语言头文件和宏定义详解

    万次阅读 多人点赞 2018-01-24 21:00:44
    之前对C语言头文件和宏定义抱着一知半解的态度,现理清思路并以文字的形式整理出来,以供不时之需 头文件 头文件,顾名思义就是定义C语言文件头部的那一坨东西 #include 这就是一个标准输入输出的...

    之前对C语言的头文件和宏定义抱着一知半解的态度,现理清思路并以文字的形式整理出来,以供不时之需

    头文件

    头文件,顾名思义就是定义在C语言文件头部的那一坨东西

    #include <stdio.h>
    

    这就是一个标准输入输出的头文件声明,头文件声明写在定义文件(后缀名.c的文件)的头部,并在定义文件中具体实现

    #include <stdlib.h>
    #include "mylib.h"
    

    这是两种声明头文件的方法,其中尖括号表示 “到环境指定的目录去引用”,而双引号表示 “首先在当前目录查找,然后在到环境指定的目录去引用”。在C标准库中每个库函数都在一个头文件中声明,可以通过第一种方式引用。

    头文件的格式

    #ifndef _MYLIB_H_
    #define _MYLIB_H_
    ...
    #endif
    
    

    第一句“ifndef”意思是“如果在导入头文件的文件中之前没有导入该头文件就编译下面的代码”,该句的作用是防止重复导入
    第二句“define”是“宏定义”的意思,表示以下代码是的头文件主体部分
    最后来一句“endif”和“ifdef”首尾呼应
    其中“ifndef”和“define”后面跟的是相同的“标识”,通常和头文件名相同,所有字母均大写并把点号改为下划线即可

    #include "mylib.h"
    

    看到这句话后编译器会把该头文件“mylib.h”复制粘贴到导入的文件中,之后你就可以使用头文件中定义的常量和结构定义了

    显然恰当地使用头文件有利于更好的组织文件和项目

    提请注意
    1、头文件只是声明,不占内存;在编译时会被合并到源文件
    2、头文件和其它C语言文件一样可以引用其它文件,可以写预处理块但是不要出现具体语句
    3、可以在头文件中定义宏函数,其本质上还是一个声明
    4、各个头文件相互独立,标准头文件之间不存在相互包含关系
    5、头文件可以重复引用,但是相当于只导入一次
    6、 从C语法角度讲完全可以在头文件中写任何东西,因为#include在作用上和Ctrl-C + Ctrl-V等效——但是这样时不推荐的;头文件的作用就是更好的组织代码

    何时使用
    1、结构体的定义
    2、函数声明,变量声明,宏定义,常数定义等
    3、当源代码不便公布时使用头文件提供接口
    4、在大项目中需要多文件联合编译

    小栗子

    #ifndef _NODE_H_
    #define _NODE_H_
    
    typedef struct _node{
    	int value;
    	struct _node* next;
    } Node;
    
    #endif
    
    #include "node.h"
    int main(int argc, char const argv[])
    {
    	Node* p = (Node*)malloc(sizeof(Node));
    	...
    	return 0;
    }
    

    常用头文件

    stdio.h 标准输入输出
    stdlib.h 标准常用库
    string.h 字符串函数库
    math.h 数学库
    ctype.h 字符函数库
    time.h 时间库
    windows.h 微软视窗库


    宏定义

    宏定义是C语言提供的三种预处理功能的其中一种,这三种预处理包括:宏定义、文件包含、条件编译。宏定义和操作符的区别是:宏定义是替换,不做计算,也不做表达式求解。“宏定义” 也称 “宏替换”、“宏”。

    define PI 3.1415926
    

    这就是一个简单的宏,在程序的预处理阶段宏名会被替换为后面的字符串

    传入参数的宏

    1、 #:字符串化操作,即将宏定义中的传入参数名转换成用一对双引号括起来参数名字符串,使用时置于宏定义体中的参数名前,如:

    #define func(para)  #para
    ...
    char str[] = func(hello); //被展开为:char str[]="hello"
    

    说明:如果传入的参数之前有空格则忽略之,如果参数之间有多个空格则在连成字符串时只算一个

    2、 #@:字符化操作,即将宏定义传入的参数名转换为用一对单引号扩起来的参数名字符串,使用时置于参数名前,如:

    #define fun(pa) #@pa
    char a = fun(a); //被展开为char a='a';
    

    3、 ##:参数连接操作,即将宏定义的多个形参连接成一个实际参数,如:

    #define COMMAND(a, b) a##b
    ...
    COMMAND(1, 2); //相当于12
    CMOOAND(ac, b); //相当于acb
    

    4、\:当前行继续操作,实际上是对换行符转义,如:

    #define LOOP(FROM, TO, CONTENT)\
    for (int i = FROM; i < TO; i++) {\
        CONTENT\
    }
    

    5、 __VA_ARGS__:变长参数操作,即可以接受不定个数的参数,如:

    #define eprintf(...) fprintf (stderr, __VA_ARGS__)
    eprintf ("%s:%d: ", input_file, lineno)
    //==>  fprintf (stderr, "%s:%d: ", input_file, lineno)
    

    为什么要使用宏定义

    简而言之,使用宏定义可以提高代码的可读性。具体的说,可以减少magic number的使用,并且可以做一些方便的替换,如下面的代码:

    #define MALLOC(n, type) (type*)malloc((n) * sizeof(type))
    

    使用时,int *p=MALLOC(10, int); 即可

    宏的规范写法
    1、宏名大写
    2、宏定义语句末尾不加分号
    3、宏函数的形式参数不加类型

    另外宏定义需要注意的
    1、宏定义可以嵌套
    2、宏定义不能出现在字符串的“”中
    3、宏定义不分配内存,变量定义才分配内存
    4、宏定义只是简单的替换,而且是直接对源码的字符串替换,如下面的宏定义就不能很好的表达求平方函数:

    #define sqrt(x) x * x
    ...
    int y = sqrt(1 + 2); //y = 1 + 2 * 1 + 2 = 5 ≠9
    

    这时候加上括号就好了:

    #define sqrt(x) (x) * (x)
    ...
    int y=sqrt(1+2); //y = (1 + 2) * (1 + 2) = 9
    

    5、宏函数和自定义函数相比,效率更高但是安全性低且会使编译生成的目标文件变大;宏函数没有分配和释放栈帧、传参、传返回值等一系列工作,适合那些简短并且频繁调用的函数,但是对于递归则不推荐使用宏



    (补;GCC 的一个小技巧)

    #include <stdio.h>
    
    #define GREATER(a, b) ({\
    	int ret;\
    	if (a > b) ret = a;\
    	else ret = b;\
    	ret;\
    })
    
    
    int main(void)
    {
    	printf("1 and 2, which is greater? %d\n", GREATER(1, 2)); //2
    	printf("6 and 5, which is greater? %d\n", GREATER(6, 5)); //6
    }
    

    可以把define当简陋的的函数返回来用。注意到这是一个gcc扩展,MSVC不能用哦。

    #define WHATEVER() ({\
    	sd::cout << "WHATEVER" << std::endl;
    }) // 报错,因为没有返回值
    
    #define WHATEVER() ({\
    	std::cout << "WHATEVER" <<std::endl;\
    	int datafield = 1024;\ // 用数据冒充返回值,这样就不会报错辽
    }
    

    如果是一般的void类型的函数,也就是不带返回值的函数(in other words, 子例程、代码块……),我们更常用的是用一个do-while(0) 括起来,非常简单,可惜就是不能带返回值。

    #include <iostream>
    
    #define WHATEVER() do \{
    	std::cout << "whatever" << std::endl;\
    } while (0)
    
    
    int main(void)
    {
    	WHATEVER(); // "whatever"
    }
    

    (完)

    展开全文
  • C语言自定义头文件

    千次阅读 2021-05-31 17:30:19
    一些初学C语言的人,不知道头文件(*.h文件)原来还可以自己写的。只知道调用系统库函数时,要使用#include语句将某些头文件包含进去。其实,头文件跟.C文件一样,是可以自己写的。头文件是一种文本文件,使用文本...

    头文件其实就是类似<stdio.h>这样的.h文件,和c一样,但需要放在规定目录当中,文件中放置了一些函数声明,变量声明,常数定义,宏的定义等等。当使用#include语句将头文件引用时,就等价于将头文件中所有内容,复制到#include处。头文件的格式通常为:

    #ifndef DELAY_H

    #define DELAY_H

       //代码部分
    

    #endif

    的格式。

    其中,DELAY为一个唯一的标号,命名规则跟变量的命名规则一样。常根据它所在的头文件名来命名,例如,如果头文件的文件名叫做stc15w.h,那么可以这样使用:

    #ifndef 1

    #define 1

       //代码部分
    

    #endif

    这样写的意思就是,如果没有定义1,1,并编译下面的代码部分,直到遇到#endif。这样,当重复引用时,由于1已经被定义,则下面的代码部分就不会被编译了,这样就避免了重复定义。另外,使用#include时,使用引号“”与尖括号<>的意思是不一样的。使用引号“”时,首先搜索工程文件所在目录,然后再搜索编译器头文件所在目录;而使用尖括号< >时,刚好是相反的搜索顺序。

    假设我们有两个文件名一样的头文件1.h,但内容却是不一样的。一个保存在编译器指定的头文件目录下,我们把它叫做文件I;另一个则保存在当前工程的目录下,我们把它叫做文件II。如果我们使用的是#include <>,则我们引用到的是文件I。如果我们使用的是#include “1.h”,则我们引用的将是文件II。

    /*--------------------------------------------------------------------------
    INTRINS.H
    
    Intrinsic functions for C51.
    Copyright (c) 1988-2010 Keil Elektronik GmbH and ARM Germany GmbH
    All rights reserved.
    --------------------------------------------------------------------------*/
    
    #ifndef __INTRINS_H__
    #define __INTRINS_H__
    
    #pragma SAVE
    
    #if defined (__CX2__)
    #pragma FUNCTIONS(STATIC)
    /* intrinsic functions are reentrant, but need static attribute */
    #endif
    
    extern void          _nop_     (void);
    extern bit           _testbit_ (bit);
    extern unsigned char _cror_    (unsigned char, unsigned char);
    extern unsigned int  _iror_    (unsigned int,  unsigned char);
    extern unsigned long _lror_    (unsigned long, unsigned char);
    extern unsigned char _crol_    (unsigned char, unsigned char);
    extern unsigned int  _irol_    (unsigned int,  unsigned char);
    extern unsigned long _lrol_    (unsigned long, unsigned char);
    extern unsigned char _chkfloat_(float);
    #if defined (__CX2__)
    extern int           abs       (int);
    extern void          _illop_   (void);
    #endif
    #if !defined (__CX2__)
    extern void          _push_    (unsigned char _sfr);
    extern void          _pop_     (unsigned char _sfr);
    #endif
    
    #pragma RESTORE
    
    #endif
    
    
    

    pragma用于指定一些编译信息:
    (1) #pragma message 用于自定义编译信息

    (2)#pragma once 用于保证头文件只被编译一次

    (3)#pragama pack用于指定内存对齐(一般用在结构体)

    展开全文
  • C语言头文件详解

    千次阅读 2020-06-26 21:43:06
    C语言头文件详解 引言 在C语言家族程序中,头文件被大量使用。一般而言,每个C++/C程序通常由头文件(header files)和定义文件(definition files)组成。头文件作为一种包含功能函数、数据接口声明的载体文件,主要...

    C语言的头文件详解

    在这里插入图片描述

    引言

    在C语言家族程序中,头文件被大量使用。一般而言,每个C++/C程序通常由头文件(header files)和定义文件(definition files)组成。头文件作为一种包含功能函数、数据接口声明的载体文件,主要用于保存程序的声明(declaration),而定义文件用于保存程序的实现 (implementation)。 .c就是你写的程序文件

    头文件的作用

    一般在一个应用开发体系中,功能的真正逻辑实现是以硬件层为基础,在驱动程序、功能层程序以及用户的应用程序中完成的。头文件的主要作用在于多个代码文件全局变量(函数)的重用、防止定义的冲突,对各个被调用函数给出一个描述,其本身不需要包含程序的逻辑实现代码,它只起描述性作用,用户程序只需要按照头文件中的接口声明来调用相关函数或变量,链接器会从库中寻找相应的实际定义代码。头文件是用户应用程序和函数库之间的桥梁和纽带。在整个软件中,头文件不是最重要的部分,但它是C语言家族中不可缺少的组成部分。编译时,编译器通过头文件找到对应的函数库,进而把已引用函数的实际内容导出来代替原有函数。进而在硬件层面实现功能。

    什么样的内容适合放在头文件里?对于具有外部存储类型的标识符,可以在其他任何一个源程序文件中经声明后引用,因此用户完全可以将一些具有外部存储类型的标识符的声明放在一个头文件中。具体地说,头文件中可以包括:用户构造的数据类型(如枚举类型),外部变量,外部函数、常量和内联函数等具有一定通用性或常用的量。而一般性的变量和函数定义不宜放在头文件中。例如:#include<stdio.h>中的头文件stdio.h作用是让链接器通过头文件里的函数声明找到函数实际代码所在的位置即所在的库文件,这样才能使用该函数的实际代码,函数的实际代码的实现过程是先让链接器通过头文件里函数的申明找到函数实际代码所在的位置即所在的库文件,再通过#include语句把链接器所找到的函数实际代码用链接器把函数的实际代码链接到当前文件即所要执行的程序中。当然有些函数的使用不需要提供头文件,但是在ISO/ANSI C已经对有些函数的使用必须提供哪些头文件制定了标准。

    头文件的用法总结

    头文件最常用的形式如下:

    • 明示常量——例如,stdio.h中定义的EOF、NULL和BUFSIZE(标准I/O缓冲区大小)。
    • 宏函数——例如,getc(stdio.h)通常用getchar()定义,而getc()经常用于定义较复杂的宏,头文件ctype.h通常包含ctype系列函数的定义。
    • 函数声明——例如,string.h头文件(一些旧的系统是srings.h)包含字符串函数系列的函数声明。在ANSI C和后面的标准中,函数声明都是函数原型形式。
    • 结构模板定义——标准I/O函数使用FILE结构,该结构中包含了文件和缓冲区相关信息。FILE结构在头文件stdio.h中。
    • 类型定义——标准I/O函数使用指向FILE的指针为参数。通产stdio.h用#define或typedef把FILE定义为指向结构的指针。类似的,size_t和time_t类型也定义在头文件中。

    其他用法

    许多程序员在程序中使用自己开发的标准头文件。如果开发一些列相关的函数或结构,那么这种方法特别有价值。

    另外,还可以使用头文件声明外部变量供其他文件共享。例如,如果已经开发了共享某个变量的一系列函数,该变量报告某种情况(如错误情况),这种方法就很有效。这种情况下,可以在包含这些函数声明的源代码文件定义一个文件作用域的外部链接变量:

    int status = 0; //该变量具有文件作用域,在源代码文件
    

    然后,可以在与源代码文件相关联的头文件中进行引用式声明:

    extern int status; //在头文件中
    

    这行代码出现在包含了该头文件的文件中,这样使用该系列函数的文件都能使用这个变量。虽然源代码文件中包含该头文件后也包含了该声明,但是只要声明的类型一致,在一个文件中同时使用定义式声明和引用式声明没问题。

    需要包含头文件的另外一种情况是,使用具有文件作用域、内部链接和const限定符的变量或数组。const防止值被意外修改,static意味着每个包含该头文件的文件都获得一份副本。因此,不需要在一个文件中进行定义式声明,在其他文件中进行引用式证明。


    [1] 百度百科-头文件
    [2] 史蒂芬・普拉达. C Primer Plus (第6版) 中文版[M]. 人民邮电出版社, 2016.

    展开全文
  • C语言常用头文件

    2021-04-01 17:44:02
    } 运行结果 ctype.h 借鉴自C标准库 定义了一批C语言字符分类函数(C character classification functions),用于测试字符是否属于特定的字符类别,如字母字符、控制字符等等。既支持单字节字符,也支持宽字符。 ...

    stdio.hstandard input & output

    标准输入输出

    stdlib.hstandard library

    标准库头文件。

    里面定义了五种类型、一些宏和通用工具函数。类型例如size_t、wchar_t、div_t、ldiv_t和lldiv_t; 宏例如EXIT_FAILURE、EXIT_SUCCESS、RAND_MAX和MB_CUR_MAX等等; 常用的函数如malloc()、calloc()、realloc()、free()、system()、atoi()、atol()、rand()、srand()、exit()等等。

    string.h

    借鉴自C 标准库 - <string.h>

    头文件定义了一个变量类型、一个宏和各种操作字符数组的函数。

    1. 库变量类型
      size_t
      这是无符号整数类型,它是 sizeof 关键字的结果。

    2. 库宏
      NULL
      这个宏是一个空指针常量的值。

    3. 库函数

    • strcat()函数
      *原型:char *strcat(char *dest, const char src)
      作用:把src所指向的字符串追加到dest 所指向的字符串的结尾。
    • strcmp()函数
      *原型:int strcmp(const char *str1, const char str2)
      作用:把 str1 所指向的字符串和 str2 所指向的字符串进行比较。
    • strcpy()函数
      *原型:char *strcpy(char *dest, const char src)
      作用:把 src 所指向的字符串复制到 dest。
    • strlen()函数
      *原型:size_t strlen(const char str)
      作用:计算字符串 str 的长度,直到空结束字符,但不包括空结束字符。
    • memchr()函数
      *原型:void *memchr(const void str, int c, size_t n)
      作用:在参数 str 所指向的字符串的前 n 个字节中搜索第一次出现字符 c(一个无符号字符)的位置。
    • memcmp()函数
      *原型:int memcmp(const void *str1, const void str2, size_t n)
      作用:把 str1 和 str2 的前 n 个字节进行比较。
    • memcpy()函数
      *原型:void *memcpy(void *dest, const void src, size_t n)
      作用:从 src 复制 n 个字符到 dest。
    • memmove()函数
      *原型:void *memmove(void *dest, const void src, size_t n)
      作用:另一个用于从 src 复制 n 个字符到 dest 的函数。
    • memset()函数
      *原型:void *memset(void str, int c, size_t n)
      作用:复制字符 c(一个无符号字符)到参数 str 所指向的字符串的前 n 个字符。
    • strncat()函数
      *原型:char *strncat(char *dest, const char src, size_t n)
      作用:把 src 所指向的字符串追加到 dest 所指向的字符串的结尾,直到 n 字符长度为止。
    • strchr()函数
      *原型:char *strchr(const char str, int c)
      作用:在参数 str 所指向的字符串中搜索第一次出现字符 c(一个无符号字符)的位置。
    • strncmp()函数
      *原型:int strncmp(const char *str1, const char str2, size_t n)
      作用:把 str1 和 str2 进行比较,最多比较前 n 个字节。
    • strcoll()函数
      *原型:int strcoll(const char *str1, const char str2)
      作用:把 str1 和 str2 进行比较,结果取决于 LC_COLLATE 的位置设置。
    • strncpy()函数
      *原型:char *strncpy(char *dest, const char src, size_t n)
      作用:把 src 所指向的字符串复制到 dest,最多复制 n 个字符。
    • strcspn()函数
      *原型:size_t strcspn(const char str1, const char str2)
      作用:检索字符串 str1 开头连续有几个字符都不含字符串 str2 中的字符。
    • strerror()函数
      *原型:char strerror(int errnum)
      作用:从内部数组中搜索错误号errnum,并返回一个指向错误消息字符串的指针。
    • strpbrk()函数
      *原型:char *strpbrk(const char *str1, const char str2)
      作用:检索字符串 str1 中第一个匹配字符串 str2 中字符的字符,不包含空结束字符。也就是说,依次检验字符串 str1 中的字符,当被检验字符在字符串 str2 中也包含时,则停止检验,并返回该字符位置。
    • strrchr()函数
      *原型:char *strrchr(const char str, int c)
      作用:在参数 str 所指向的字符串中搜索最后一次出现字符 c(一个无符号字符)的位置。
    • strspn()函数
      *原型:size_t strspn(const char *str1, const char str2)
      作用:检索字符串 str1 中第一个不在字符串 str2 中出现的字符下标。
    • strstr()函数
      *原型: char *strstr(const char *haystack, const char needle)
      作用:在字符串 haystack 中查找第一次出现字符串 needle(不包含空结束字符)的位置。
    • strtok()函数
      *原型: char *strtok(char *str, const char delim)
      作用:分解字符串 str 为一组字符串,delim 为分隔符。
    • strxfrm()函数
      *原型:size_t strxfrm(char *dest, const char src, size_t n)
      作用:根据程序当前的区域选项中的 LC_COLLATE 来转换字符串 src 的前 n 个字符,并把它们放置在字符串 dest 中。

    math.h

    头文件中声明了常用的一些数学运算

    1. 三角函数
      double sin(double);正弦
      double cos(double);余弦
      double tan(double);正切

    2. 反三角函数
      double asin (double); 结果介于[-PI/2,PI/2]
      double acos (double); 结果介于[0,PI]
      double atan (double); 反正切(主值),结果介于[-PI/2,PI/2]
      double atan2 (double,double); 反正切(整圆值),结果介于[-PI,PI]

    3. 双曲三角函数
      double sinh (double);
      double cosh (double);
      double tanh (double);

    4. 指数与对数
      double frexp(double value,int *exp);这是一个将value值拆分成小数部分f和(以2为底的)指数部分exp,并返回小数部分f,即f·2^exp。其中f取值在0.5~1.0范围或者0。
      double ldexp(double x,int exp);这个函数刚好跟上面那个frexp函数功能相反,它的返回值是x*2^exp
      double modf(double value,double *iptr);拆分value值,返回它的小数部分,iptr指向整数部分。
      double log (double); 以e为底的对数
      double log10 (double);以10为底的对数
      double pow(double x,double y);计算x的y次幂
      float powf(float x,float y); 功能与pow一致,只是输入与输出皆为单精度浮点数
      double exp (double);求取自然数e的幂
      double sqrt (double);开平方根

    5. 取整
      double ceil (double); 取上整,返回不比x小的最小整数
      double floor (double); 取下整,返回不比x大的最大整数,即 高斯函数[x]

    6. 绝对值
      int abs(int i); 求整型的绝对值
      double fabs (double);求实型的绝对值
      double cabs(struct complex znum);求复数的绝对值

    7. 标准化浮点数
      double frexp (double f,int *p); 标准化浮点数,f = x * 2^p,已知f求x,p (x介于[0.5,1])
      double ldexp (double x,int p); 与frexp相反,已知x,p求f

    8. 取整与取余
      double modf (double,double*); 将参数的整数部分通过指针回传,返回小数部分
      double fmod (double,double); 返回两参数相除的余数

    9. 其他
      double hypot(double x,double y);已知直角三角形两个直角边长度,求斜边长度
      double ldexp(double x,int exponent);计算x*(2的exponent次幂)
      double poly(double x,int degree,double coeffs []);计算多项式
      int matherr(struct exception *e);数学错误计算处理程序

    source: 《C & C++ Code Capsules》

    assert.h

    头文件提供了一个名为 assert 的宏

    void assert(int expression)
    这实际上是一个宏,不是一个函数,可用于在 C 程序中添加诊断。它可用于验证程序做出的假设,并在假设为假时输出诊断消息。

    limits.h

    转载自C 标准库 - <limits.h>

    头文件决定了各种变量类型的各种属性。定义在该头文件中的宏限制了各种变量类型(比如 char、int 和 long)的值。
    这些限制指定了变量不能存储任何超出这些限制的值,例如一个无符号可以存储的最大值是 255。

    库宏

    描述
    CHAR_BIT8定义一个字节的比特数。
    SCHAR_MIN-128定义一个有符号字符的最小值。
    SCHAR_MAX127定义一个有符号字符的最大值。
    UCHAR_MAX255定义一个无符号字符的最大值。
    CHAR_MIN0定义类型 char 的最小值,如果 char 表示负值,则它的值等于 SCHAR_MIN,否则等于 0。
    CHAR_MAX127定义类型 char 的最大值,如果 char 表示负值,则它的值等于 SCHAR_MAX,否则等于 UCHAR_MAX。
    MB_LEN_MAX1定义多字节字符中的最大字节数。
    SHRT_MIN-32768定义一个短整型的最小值。
    SHRT_MAX+32767定义一个短整型的最大值。
    USHRT_MAX65535定义一个无符号短整型的最大值。
    INT_MIN-2147483648定义一个整型的最小值。
    INT_MAX2147483647定义一个整型的最大值。
    UINT_MAX4294967296定义一个无符号整型的最大值。
    LONG_MIN-9223372036854775808定义一个长整型的最小值。
    LONG_MAX9223372036854775807定义一个长整型的最大值。
    ULONG_MAX1.8446744e+19定义一个无符号长整型的最大值。

    实例

    #include <stdio.h>
    #include <limits.h>
    
    int main()
    {
    
       printf("The number of bits in a byte %d\n", CHAR_BIT);
    
       printf("The minimum value of SIGNED CHAR = %d\n", SCHAR_MIN);
       printf("The maximum value of SIGNED CHAR = %d\n", SCHAR_MAX);
       printf("The maximum value of UNSIGNED CHAR = %d\n", UCHAR_MAX);
    
       printf("The minimum value of SHORT INT = %d\n", SHRT_MIN);
       printf("The maximum value of SHORT INT = %d\n", SHRT_MAX);
    
       printf("The minimum value of INT = %d\n", INT_MIN);
       printf("The maximum value of INT = %d\n", INT_MAX);
    
       printf("The minimum value of CHAR = %d\n", CHAR_MIN);
       printf("The maximum value of CHAR = %d\n", CHAR_MAX);
    
       printf("The minimum value of LONG = %ld\n", LONG_MIN);
       printf("The maximum value of LONG = %ld\n", LONG_MAX);
     
       return(0);
    }
    

    运行结果

    在这里插入图片描述

    ctype.h

    借鉴自C标准库<ctype.h>

    定义了一批C语言字符分类函数(C character classification functions),用于测试字符是否属于特定的字符类别,如字母字符、控制字符等等。既支持单字节字符,也支持宽字符。

    库函数

    • int isalnum(int c)
      该函数检查所传的字符是否是字母和数字。
    • int isalpha(int c)
      该函数检查所传的字符是否是字母。
    • int iscntrl(int c)
      该函数检查所传的字符是否是控制字符。
    • int isdigit(int c)
      该函数检查所传的字符是否是十进制数字。
    • int isgraph(int c)
      该函数检查所传的字符是否有图形表示法。
    • int islower(int c)
      该函数检查所传的字符是否是小写字母。
    • int isprint(int c)
      该函数检查所传的字符是否是可打印的。
    • int ispunct(int c)
      该函数检查所传的字符是否是标点符号字符。
    • int isspace(int c)
      该函数检查所传的字符是否是空白字符。
    • int isupper(int c)
      该函数检查所传的字符是否是大写字母。
    • int isxdigit(int c)
      该函数检查所传的字符是否是十六进制数字。
    • int tolower(int c)
      该函数把大写字母转换为小写字母。
    • int toupper(int c)
      该函数把小写字母转换为大写字母。

    <time.h>

    转载自C 标准库 - <time.h>

    头文件定义了四个变量类型、两个宏和各种操作日期和时间的函数。

    库变量

    • size_t
      是无符号整数类型,它是 sizeof 关键字的结果。
    • clock_t
      这是一个适合存储处理器时间的类型。
    • time_t is
      这是一个适合存储日历时间类型。
    • struct tm
      这是一个用来保存时间和日期的结构。
      tm 结构的定义如下:
    struct tm {
       int tm_sec;         /* 秒,范围从 0 到 59        */
       int tm_min;         /* 分,范围从 0 到 59        */
       int tm_hour;        /* 小时,范围从 0 到 23        */
       int tm_mday;        /* 一月中的第几天,范围从 1 到 31    */
       int tm_mon;         /* 月,范围从 0 到 11        */
       int tm_year;        /* 自 1900 年起的年数        */
       int tm_wday;        /* 一周中的第几天,范围从 0 到 6    */
       int tm_yday;        /* 一年中的第几天,范围从 0 到 365    */
       int tm_isdst;       /* 夏令时                */
    };
    

    库宏

    • NULL
      这个宏是一个空指针常量的值。
    • CLOCKS_PER_SEC
      这个宏表示每秒的处理器时钟个数。

    库函数

    • char *asctime(const struct tm *timeptr)
      返回一个指向字符串的指针,它代表了结构 timeptr 的日期和时间。
    • clock_t clock(void)
      返回程序执行起(一般为程序的开头),处理器时钟所使用的时间。
    • char *ctime(const time_t *timer)
      返回一个表示当地时间的字符串,当地时间是基于参数 timer。
    • double difftime(time_t time1, time_t time2)
      返回 time1 和 time2 之间相差的秒数 (time1-time2)。
    • struct tm *gmtime(const time_t *timer)
      timer 的值被分解为 tm 结构,并用协调世界时(UTC)也被称为格林尼治标准时间(GMT)表示。
    • struct tm *localtime(const time_t *timer)
      timer 的值被分解为 tm 结构,并用本地时区表示。
    • time_t mktime(struct tm *timeptr)
      把 timeptr 所指向的结构转换为一个依据本地时区的 time_t 值。
    • size_t strftime(char *str, size_t maxsize, const char *format, const struct tm *timeptr)
      根据 format 中定义的格式化规则,格式化结构 timeptr 表示的时间,并把它存储在 str 中。
    • time_t time(time_t *timer)
      计算当前日历时间,并把它编码成 time_t 格式。
    展开全文
  • C语言常见头文件汇总

    万次阅读 多人点赞 2020-05-12 23:45:54
    8.(limits.h) 整数类型的大小 该头文件定义了常量,并限制了所使用的特定系统和编译器实现的基本整数类型。 基本浮点类型的限制在()中定义。 特定于宽度的整数类型和其他typedef类型的限制在()中定义。 宏...
  • C语言头文件定义全局变量的技巧

    千次阅读 2020-05-01 12:48:42
    在刚开始学习C语言的时候,可能很多人都听过前辈说要少用goto,少用do{}while(),不要在头文件定义全局变量等,但实际上每个特性都有其合适的应用场合,只要正确的使用是不会有问题的,相反还可能给代码带来好处。
  • C语言编写头文件

    千次阅读 多人点赞 2019-05-10 23:20:57
    通常我们写C程序时,都会直接使用这样的语句“#include <...2,头文件可以定义很多宏定义,就是一些全局静态变量的定义,在这样的情况下,只要修改头文件的内容,程序 就可以做相应的修改,不用亲自...
  • c语言 编写头文件

    2019-10-08 16:19:27
    通常我们写C程序时,都会直接使用这样的语句“#include <stdio.h>”。这便是我们通常说的头文件头文件通常用作函数声明,变量声明,常数定义,宏的定义...2,头文件可以定义很多宏定义,就是一些全局静态...
  • c语言头文件编写

    千次阅读 2019-07-12 14:18:37
    使用头文件的作用:当前.c文件要使用其它.c文件已定义的全局函数/全局变量时,对使用的全局函数/全局变量进行声明。 头文件里一般存在的内容: 文件包含:文件包含语句的功能是把指定的文件插入该语句行位置,从而...
  • 可以定义,但是不推荐在头文件定义变量。 因为很多.c文件都可以包含.h文件,也就是说这个变量会在很多.c文件中存在一个副本。假如这是一个多文件项目,在连接阶段,连接器就会抱怨存在多个相同变量名的全局变量,...
  • C语言如何定义,添加头文件

    万次阅读 多人点赞 2018-11-15 19:55:11
    C语言头文件的常用格式如下: #ifndef LABLE #define LABLE //代码部分 #endif 其中,LABLE为一个唯一的标号,命名规则跟变量的命名规则一样。 常根据它所在的头文件来命名 举列如下: // 头文件hardware.h...
  • C语言头文件定义

    2020-07-18 13:06:20
    //在头文件当中可以定义一些接口(函数原型)和类型 全局变量等 //为了避免编译时间和效率过低 不要将实现部分放在头文件当中 #ifndef _TEST_HEADER_H_ #define _TEST_HEADER_H_ void display_message(); typedef ...
  • C语言基础:C语言头文件

    千次阅读 2020-06-22 19:20:29
    本文从Simulink生成的代码出发,研究C语言头文件的作用。 文章目录1 头文件的作用2 C文件中引用头文件3 头文件的内容 1 头文件的作用 博主理解,头文件的作用可以归纳为一句话,那就是把各个C文件联系起来。 至于...
  • 3、定义宏、类型别名 4、包含其它头文件 二、包含头文件时要注意 #include <name.h> 从系统指定的位置加载。 #include " name.h" 先从当前目录下加载,如果当前目前没有再从系统指定的位置加载。 当没函数声明...
  • c语言常用头文件

    千次阅读 2018-04-17 19:55:44
    #include &lt;assert.h&gt; //设定插入点#include &... //定义错误码#include &lt;float.h&gt; //浮点数处理#include &lt;fstream.h&gt; //文件输入/输出#include &lt;ioman...
  • 一些初学C语言的人,不知道头文件(*.h文件)原来还可以自己写的。只知道调用系统库函数时,要使用#i nclude语句将某些头文件包含进去。其实,头文件跟.C文件一样,是可以自己写的。头文件是一种文本文件,使用文本...
  • C语言中的头文件中的宏定义

    千次阅读 2020-10-08 16:23:04
    源文件的头部一般都会有#include指令来包含头文件头文件的内容一般就是 #define语句 extern声明 函数原型声明 #include和#define都是C的预处理指令,#include就是把文件中的所有内容粘贴到源文件中,仅此而已! ...
  • C语言头文件的导入

    千次阅读 2020-03-15 10:10:06
    首先,对于很多萌新编程者,把所有函数...首先我们创建一个简单的C语言函数,并且导入我们字节写的头文件。以下为头文件以及保存方式: 以上为我们的头文件,里面需要包括导入的库函数、宏定义以及我们所定义的函数...
  • 1.创建一个新项目 2.在项目中新建空白文件 3.重命名为头文件(后缀为.h) 图标为 4.头文件里面的写法 ...//中间就是你想要定义的东西,比如函数,结构体 //注意:里面不能有main函数 #endif ...
  • C语言头文件和源文件的注意事项

    千次阅读 2019-08-03 15:34:13
    总结2.1头文件内容2.2 源文件(.c)内容2.3 函数声明和定义 0.前言 因为C语言编程或者C++语言编程,经常要添加头文件,不像Python中直接引入第三库就可以(import),但是嵌入式编程中C还是主流,Python目前这方面的...
  • 在<KEIL编译器预处理器和预定义宏(include,ifdef,def等)>...同时,各种宏定义,变量定义,函数定义等就会相当的多,这样一来,在我们引用一个定义的时候,就要去包含非常多的头文件进来。在一个C文件前面...
  • C语言头文件详解

    万次阅读 多人点赞 2019-05-11 14:08:47
    简单一句话:在include的地方,把头文件里的内容原封不动的复制到引用该头文件的地方。 头文件的引用 头文件引用有两种形式:#include < stdio.h> 和 include "main.h “。 用< >引用的一般是编译器提供...
  • C语言常用头文件及库函数

    千次阅读 2017-04-05 00:27:25
    6个常用头文件及库函数
  • C语言头文件和源文件的关系

    千次阅读 2019-06-27 10:34:51
    答案 #include预处理实际上就是完成了一个“复制代码并插入”的工作!...编译器以C文件作为一个单元,开始读C文件,读到包含头文件的语句时,从所有搜索路径寻找头文件。 找到后,处理宏,变量,函数声明,检测...
  • c语言常用头文件以及内部函数

    千次阅读 多人点赞 2018-04-16 19:41:38
    C标准中的数据格式并不符合IEEE754标准,一些C语言编译器却遵循IEEE754(例如frinklin C51) ----------------------------------------  反余弦 acos 反正弦 asin 反正切 atan 反正切2 atan2 余弦 cos 正弦 ...
  • <C语言>头文件封装

    千次阅读 2017-08-08 20:14:52
    使用C语言编写程序的时候,我们往往会用到很多头文件,然而作为一个偷懒的程序员,我实在嫌麻烦, 所以做了一个头文件封装,把大部分用到的头文件都封装到了我自己的命名头文件中。从此,在头文件引用时我只需要#...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 115,960
精华内容 46,384
关键字:

c语言如何定义头文件

c语言 订阅