C程序设计语言的笔记(46)

按有用程度 按页码先后 最新笔记

• 

  第4页

  eddyzhou (stay hungry,stay foolish)

  float类型通常是32位，它至少有6位有效数字，取值范围一般在10^-38 ~ 10 ^ 38之间 1 范围 float和double的范围是由指数的位数来决定的。 float的指数位有8位，而double的指数位有11位，分布如下： float： 1bit（符号位） 8bits（指数位） 23bits（尾数位） double： 1bit（符号位）11bits（指数位）52bits（尾数位） 于是，float的指数范围为-127~128，而double的指数范围为-1023~1024，并且指数位是按补码的.. (更多)

  float类型通常是32位，它至少有6位有效数字，取值范围一般在10^-38 ~ 10 ^ 38之间

  1 范围

  float和double的范围是由指数的位数来决定的。

  float的指数位有8位，而double的指数位有11位，分布如下：

  float：

  1bit（符号位） 8bits（指数位） 23bits（尾数位）

  double：

  1bit（符号位）11bits（指数位）52bits（尾数位）

  于是，float的指数范围为-127~128，而double的指数范围为-1023~1024，并且指数位是按补码的形式来划分的。其中负指数决定了浮点数所能表达的绝对值最小的数；而正指数决定了浮点数所能表达的绝对值最大的数，也即决定了浮点数的取值范围。

  float的范围为-2^128 ~ +2^128，也即-3.40E+38 ~ +3.40E+38；double的范围为-2^1024 ~ +2^1024，也即-1.79E+308 ~ +1.79E+308。

  2 精度

  float和double的精度是由尾数的位数来决定的。浮点数在内存中是按科学计数法来存储的，其整数部分始终是一个隐含着的“1”，由于它是不变的，故不能对精度造成影响。

  float：2^23 = 8388608，一共七位，这意味着最多能有7位有效数字，但绝对能保证的为6位，也即float的精度为6~7位有效数字；

  double：2^52 = 4503599627370496，一共16位，同理，double的精度为15~16位 (收起)

  2011-02-13 11:45:27   1回应

  收藏

  推荐
• 

  第131页

  onesuper (被棱角磨破了生活)

  当flag（struct）超过一个机器字长怎么办？ 做个实验： /代码内容已省略/ 当flag结构体内部定义“位”的数量小于等于32时，sizeof(flags)的结果都是4，正好是一个机器字长。 当“位”的数量大于32时，sizeof(flags)的结果变成了8，说明编译器会自动扩充flags的长度。 因为flags从32位变成了64位，因此在格式化输出时要用long long。 (更多)

  当flag（struct）超过一个机器字长怎么办？

  做个实验：

  #include<stdio.h>
  
  struct {
  	unsigned int is_0 	:	1;
  	unsigned int is_1	:	1;
  	unsigned int is_2 	:	1;
  	unsigned int is_3 	:	1;
  	unsigned int is_4 	:	1;
  	unsigned int is_5 	:	1;
  	unsigned int is_6 	:	1;
  	unsigned int is_7 	:	1;
  	unsigned int is_8 	:	1;
  	unsigned int is_9 	:	1;
  	unsigned int is_10 	:	1;
  	unsigned int is_11 	:	1;
  	unsigned int is_12 	:	1;
  	unsigned int is_13 	:	1;
  	unsigned int is_14 	:	1;
  	unsigned int is_15 	:	1;
  	unsigned int is_16 	:	1;
  	unsigned int is_17 	:	1;
  	unsigned int is_18 	:	1;
  	unsigned int is_19 	:	1;
  	unsigned int is_20 	:	1;
  	unsigned int is_21 	:	1;
  	unsigned int is_22 	:	1;
  	unsigned int is_23 	:	1;
  	unsigned int is_24 	:	1;
  	unsigned int is_25 	:	1;
  	unsigned int is_26 	:	1;
  	unsigned int is_27 	:	1;
  	unsigned int is_28 	:	1;
  	unsigned int is_29 	:	1;
  	unsigned int is_30 	:	1;
  	unsigned int is_31 	:	1;
  
          /* more than 32 bits */
  	unsigned int is_32	:	1;
  
  } flags;
  
  int main() 
  {
  	flags.is_10	=	1;
  	flags.is_32	=	1;
  	printf("%lld\n", flags);
  	printf("%d\n", sizeof(flags));
  	return 0;
  }
  

  当flag结构体内部定义“位”的数量小于等于32时，sizeof(flags)的结果都是4，正好是一个机器字长。

  当“位”的数量大于32时，sizeof(flags)的结果变成了8，说明编译器会自动扩充flags的长度。

  因为flags从32位变成了64位，因此在格式化输出时要用long long。 (收起)

  2011-07-06 11:20:24   回应

  收藏

  推荐
• 

  第61页

  疯子磊 (FIGHTING!)

  先贴一段面试中常见的试题（来源于c/c++高质量编程） char *GetMemory(void) { char p[] = "hello world"; return p; } void Test(void) { char *str = NULL; str = GetMemory(); printf(str); } 请问运行Test函数会有什么样的结果？ 答：可能是乱码。 因为GetMemory返回的是指向“栈内存”的 指针，该指针的地址不是 NULL，但其原现的 内容已经被清除，新内容不可知。 tcpl p61 代码如下 /* 把字符... (更多)

  先贴一段面试中常见的试题（来源于c/c++高质量编程）

  char *GetMemory(void)

  { char p[] = "hello world";

  return p;

  } void Test(void)

  { char *str = NULL;

  str = GetMemory();

  printf(str);

  } 请问运行Test函数会有什么样的结果？

  答：可能是乱码。

  因为GetMemory返回的是指向“栈内存”的

  指针，该指针的地址不是 NULL，但其原现的

  内容已经被清除，新内容不可知。

  tcpl p61 代码如下

  /* 把字符串s转换成相应的双精度浮点数*/

  double atof( char s[ ])

  { double val, power;

  int i, sign;

  for ( i = 0; isspace(s[i]); i++ )

  ;

  sign = (s[i] == '-' ) ? -1 : 1;

  if ( s[i] == '+' || s[i] == '-' )

  i++;

  for (val = 0.0; isdigit(s[i]); i++)

  val = 10.0 * val +(s[i] -'0' );

  if (s [i] ] = = '.')

  i++;

  for ( power = 1.0; isdigit(s[i]); i++) {

  val = 10.0 * val +(s[i] -'0' );

  power *= 10.0;

  } return sign * val / power;

  }

  最后一行代码返回的 三个变量 sign ，val ，power 均为局部变量，为什么就可以返回？

  经查阅，得知在函数返回前 三个变量的表达式（sign * val / power）结果会用临时变量保存，故不存在局部变量值在函数返回后因生命周期原因而无法返回。 (收起)

  2011-03-25 16:29:01   5回应

  收藏

  推荐
• 

  第162页

  flychen (关注搜索引擎,linux,mysql技术)

  存储分配程序 (更多)

  存储分配程序 (收起)

  2012-06-04 13:54:56   回应

  收藏

  推荐
• 

  第112页

  flychen (关注搜索引擎,linux,mysql技术)

  结构成员运算符 (更多)

  结构成员运算符 (收起)

  2012-05-30 17:04:28   回应

  收藏

  推荐
• 

  第105页

  flychen (关注搜索引擎,linux,mysql技术)

  复杂声明，对任何事情解释都是一件复杂的事情 (更多)

  复杂声明，对任何事情解释都是一件复杂的事情 (收起)

  2012-05-30 16:59:14   1回应

  收藏

  推荐
• 

  第5页

  flychen (关注搜索引擎,linux,mysql技术)

  入门程序 (更多)

  入门程序 (收起)

  2012-05-22 21:31:57   回应

  收藏

  推荐
• 

  一

  溪风 (heading to free)

  1.c中for循环中必须有循环体： for(nc =0; getchar() != EOF; ++nc) ; 2. 如果程序中的幻数都以符号常量的形式出现，对程序进行大量修改就会相对容易一些 3. getchar函数从文本流中读入下一个输入字符，并将其作为结果值返回 4. 每次调用putchar函数时将打印一个字符，通常是显示在屏幕上 5.define: define constant: #define token [value] create a macro : #define MAX(a, b) ((a) > (b) ? (a) :... (更多)

  1.c中for循环中必须有循环体：

  for(nc =0; getchar() != EOF; ++nc)

  ;

  2. 如果程序中的幻数都以符号常量的形式出现，对程序进行大量修改就会相对容易一些

  3. getchar函数从文本流中读入下一个输入字符，并将其作为结果值返回

  4. 每次调用putchar函数时将打印一个字符，通常是显示在屏幕上

  5.define: define constant: #define token [value]

  create a macro : #define MAX(a, b) ((a) > (b) ? (a) : (b))

  6.我们通常把函数定义中圆括号内列表中出现的变量称为形式参数，而把函数调用中与形

  式参数对应的值称为实际参数

  7.出现在main函数之前的声明语句

  int power(int m, int n);

  表明power 函数有两个int 类型的参数，并返回一个int 类型的值。这种声明称为函数原

  型，它必须与power函数的定义和用法一致。如果函数的定义、用法与函数原型不一致，将

  出现错误。

  8.，ANSI C同较早版本C语言之间的最大区别在于函数的声明与定义方式的不同。

  power(base, n)

  int base, n;

  { }

  9.在C 语言中，所有函数参数都是“通过值”传递的。也就是说，传递给被调用函数的

  参数值存放在临时变量中，而不是存放在原来的变量中。被调用函数不能直接修改主调函数中变量的值，而只

  能修改其私有的临时副本的值。（C++则可以按引用调用，实际上，C语言不支持按引用调用，但是传递数组时，也用到了按引用传递）

  10. 必要时，也可以让函数能够修改主调函数中的变量。这种情况下，调用者需要向被调用

  函数提供待设置值的变量的地址（从技术角度看，地址就是指向变量的指针），而被调用函数

  则需要将对应的参数声明为指针类型，并通过它间接访问变量

  11.我们在谈论外部变量时谨慎地使用了定义（define）与声明

  （declaration）这两个词。“定义”表示创建变量或分配存储单元，而“声明”指的是说

  明变量的性质，但并不分配存储单元

  12.过分依赖外部变量会导致一定的风险，因为它会使

  程序中的数据关系模糊不清——外部变量的值可能会被意外地或不经意地修改，而程序的修

  改又变得十分困难。

  13.字符变量的取值是字符常量，即单个字符。字符变量的类型说明符是char。字符变量类型说明的格式和书写规则都与整型变量相同。

  例如：

  char a,b; 每个字符变量被分配一个字节的内存空间，因此只能存放一个字符。字符值是以ASCII码的形式存放在变量的内存单元之中的。如x的

  十进制ASCII码是120，y的十进制ASCII码是121。对字符变量a,b赋予'x'和'y'值： a='x';b='y';实际上是在a,b两个单元内存放120和121的二进制代码： a 0 1 1 1 1 0 0 0

  b 0 1 1 1 1 0 0 1

  所以也可以把它们看成是整型量。 C语言允许对整型变量赋以字符值，也允许对字符变量赋以整型值。在输出时， 允许把字符变量按整型量输出，也允许把整型量按字符量输出。 整型量为二字节量，字符量为单字节量，当整型量按字符型量处理时， 只有低八位字节参与处理。 (收起)

  2012-04-11 11:18:15   回应

  收藏

  推荐
• 

  第84页

  JeremyWei (上善若水)

  void 类型的指针可以存放指向任何类型的指针，比如： /代码内容已省略/ 数组名等于数组第一个元素的地址，比如： /代码内容已省略/ a[i] 与 *(a+i) 等价，实际上在计算a[i]的时候，C语言先将其转换成*(a+i)的形式，然后再求值，同理 &a[i] 与 a+i 也是一样的。同样，如果pa为一个指针，那么，在表达式中也可以在它后面加下标，pa[i] 与 *(pa+i) 是... (更多)

  void 类型的指针可以存放指向任何类型的指针，比如：

  void *p_void;
  int *p_int;
  char *p_char;
  
  p_void = p_int;
  p_void = p_char;
  

  数组名等于数组第一个元素的地址，比如：

  int a[3];
  int *p, *p1;
  int i;
  
  for (i = 0; i < 3; i++)
  {
  	a[i] = i;
  }
  
  //p与p1指向的内容一样
  p = a;
  p1 = &a[0];
  

  a[i] 与 *(a+i) 等价，实际上在计算a[i]的时候，C语言先将其转换成*(a+i)的形式，然后再求值，同理 &a[i] 与 a+i 也是一样的。同样，如果pa为一个指针，那么，在表达式中也可以在它后面加下标，pa[i] 与 *(pa+i) 是等价的。

  指针与数组名的区别是：指针是变量，数组名不是变量，p=a 和 p++都是正确的，但是a=p 和 a++ 是非法的。

  把数组名传递给一个函数的时候，实际上传递的是该数组第一个元素的地址，so，如下代码：

  int strlen_new(char *s)
  {
  	int n;
  
  	for (n = 0; *s != '\0'; s++)
  		n++;
  
  	return n;
  }
  
  char array_c[4];
  for (i = 0; i < 3; i++)
  {
  	array_c[i] = 'f';
  }
  array_c[3] = '\0';
  
  int len = 0;
  len = strlen_new(array_c);
  printf("len: %i\n", len); //3
  
  len = strlen_new("hello world"); 
  printf("len: %i\n", len); //11
  

  函数中的行参 char *s 和 char s[] 是一样的，你也可以传递数组的一部分，如：f(&a[2])，这样的话在函数中可以p[-1] p[-2]，如果元素存在的话，注意不要越界。

  int array_i[3];
  for (i = 0; i < 3; i++)
  {
  	array_i[i] = i;
  }
  test(&array_i[2]);
  
  void test(int *pi)
  {
  	printf("%i\n", pi[-1]); // 前一个元素
  }
  

  (收起)

  2012-04-01 22:34:40   回应

  收藏

  推荐
• 

  第98页

  fatjay2046

  函数定义中形式参数（char * a[]）的意义。 实际上a是一个指针 这个指针指向一个指针数组，而指针数组又通常指向不同的字符串。 它等效于char **a,但是 a如果写出这个形式，就体现不出是指向指针数组的指针。 常规最易出错的地方就是认为a 是指向char的 事实上 a不指向char，不要认为最前面写char*就一定指向是char. char * a[]应该这样看 。* 说明a是指针 char []说明指向的是指针数组。也就是说存储的是指针数组首地址。... (更多)

  函数定义中形式参数（char * a[]）的意义。

  实际上a是一个指针 这个指针指向一个指针数组，而指针数组又通常指向不同的字符串。

  它等效于char **a,但是 a如果写出这个形式，就体现不出是指向指针数组的指针。

  常规最易出错的地方就是认为a 是指向char的 事实上 a不指向char，不要认为最前面写char*就一定指向是char.

  char * a[]应该这样看 。* 说明a是指针 char []说明指向的是指针数组。也就是说存储的是指针数组首地址。

  (收起)

  2012-03-07 20:42:30   回应

  收藏

  推荐