IT博客-心无尘土-随笔分类-标准C

comp.lang.c FAQ list精华整理 1.5/1.6 关于指针类型声明的问题

Yama的家 — Fri, 28 Jul 2006 05:31:00 GMT

1.5 char* p1, p2; 来声明两个指针失败的原因。作成中。。。。。。。。。。。。。。。。。。

结果是p1为指针，p2仅仅为char.
The * in a pointer declaration is not part of the base type; it is part of the declarator containing the name being declared (see question 1.21). That is, in C, the syntax and interpretation of a declaration is not really

type identifier ;

but rather

base_type thing_that_gives_base_type ;

where ``thing_that_gives_base_type''--the declarator--is either a simple identifier, or a notation like *p or a[10] or f() indicating that the variable being declared is a pointer to, array of, or function returning that base_type. (Of course, more complicated declarators are possible as well.)

In the declaration as written in the question, no matter what the whitespace suggests, the base type is char and the first declarator is ``* p1'', and since the declarator contains a *, it declares p1 as a pointer-to-char. The declarator for p2, however, contains nothing but p2, so p2 is declared as a plain char, probably not what was intended. To declare two pointers within the same declaration, use

	char *p1, *p2;

Since the * is part of the declarator, it's best to use whitespace as shown; writing char* invites mistakes and confusion.

comp.lang.c FAQ list ·Question 1.6

Q: I'm trying to declare a pointer and allocate some space for it, but it's not working. What's wrong with this code?

char *p;
*p = malloc(10);

A: The pointer you declared is p, not *p. See question 4.2.

Yama的家 2006-07-28 13:31 发表评论

comp.lang.c FAQ list精华整理 1.2 / 1.3/1.4 关于类型大小的讨论，具体编程关系不大，可看可不看

Yama的家 — Fri, 28 Jul 2006 05:19:00 GMT

1.2 没有强制定义标准类型大小，这样可以适应不同机器并且大部分情况下没有必要用具体大小，还可以隐藏执行细节。（文档加上个人理解,不对勿怪-yama）
Why aren't the sizes of the standard types precisely defined?

Though C is considered relatively low-level as high-level languages go, it does take the position that the exact size of an object (i.e. in bits) is an implementation detail. (The only place where C lets you specify a size in bits is in bit-fields within structures; see questions 2.25 and 2.26) Most programs do not need precise control over these sizes; many programs that do try to achieve this control would be better off if they didn't.

Type int is supposed to represent a machine's natural word size. It's the right type to use for most integer variables; see question 1.1 for other guidelines. See also questions12.42 and 20.5

1.3具体自己定义16，32位int来实现各种机器上面的整数是没有必要的。因为要注意很多事情哦（文档加上个人理解,不对勿怪-yama）
Since C doesn't define sizes exactly, I've been using typedefs like int16 and int32. I can then define these typedefs to be int, short, long, etc. depending on what machine I'm using. That should solve everything, right?

If you truly need control over exact type sizes, this is the right approach. There remain several things to be aware of:

There might not be an exact match on some machines. (There are, for example, 36-bit machines.)
A typedef like int16 or int32 accomplishes nothing if its intended meaning is ``at least'' the specified size, because types int and long are already essentially defined as being ``at least 16 bits'' and ``at least 32 bits,'' respectively.
Typedefs will never do anything about byte order problems (e.g. if you're trying to interchange data or conform to externally-imposed storage layouts).
You no longer have to define your own typedefs, because the Standard header contains a complete set.

1.4 机器上面64位的类型的支持是因为编译器大部分实现了long long类型或者他的扩展_longlong.也可以来定义short int为16位，int为32位，long int为64位来实现。（文档加上个人理解,不对勿怪-yama）

What should the 64-bit type be on a machine that can support it?

The new C99 Standard specifies type long long as effectively being at least 64 bits, and this type has been implemented by a number of compilers for some time. (Others have implemented extensions such as __longlong.) On the other hand, it's also appropriate to implement type short int as 16, int as 32, and long int as 64 bits, and some compilers do.

Yama的家 2006-07-28 13:19 发表评论

comp.lang.c FAQ list精华整理 1.1 关于选用整数类型的原则

Yama的家 — Thu, 27 Jul 2006 05:47:00 GMT

1.
    if ((n > 32,767) or (n < -32,767)) { n.selectUseType = long; }
2.
    if (there are large arrays or many structures) { n.selectUseType = short; }
3.
    if ((well-defined overflow characteristics are important ) or
        (not negative values) or
        (manipulating bits or bytes and not want to meet sign-extension problems))
    {
        n.selectUseType = unsigned n.selectUseType;
    }
4.
    assert(not use unsigned char replace integer type);
5.
    assert(sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long));
6.
    if (Under ANSI C)
    {
       nTypeMin = <limits.h>.maximum;
       nTypeMax = <limits.h>.minimum;
    }
7.
    if (want to define an exact size object)
    {
        n.selectUseType = typedef userDefineType;
    }

Yama的家 2006-07-27 13:47 发表评论

comp.lang.c FAQ list :Declarations and Initializations Question 1.1

Yama的家 — Thu, 09 Mar 2006 01:41:00 GMT

How should I decide which integer type to use

If you might need large values (above 32,767 or below -32,767), use long. Otherwise, if space is very important (i.e. if there are large arrays or many structures), use short. Otherwise, use int. If well-defined overflow characteristics are important and negative values are not, or if you want to steer clear of sign-extension problems when manipulating bits or bytes, use one of the corresponding unsigned types. (Beware when mixing signed and unsigned values in expressions, though; see question 3.19.)

Although character types (especially unsigned char) can be used as ``tiny'' integers, doing so is sometimes more trouble than it's worth. The compiler will have to emit extra code to convert between char and int (making the executable larger), and unexpected sign extension can be troublesome. (Using unsigned char can help; see question 12.1 for a related problem.)

A similar space/time tradeoff applies when deciding between float and double. (Many compilers still convert all float values to double during expression evaluation.) None of the above rules apply if pointers to the variable must have a particular type.

Variables referring to certain kinds of data, such as sizes of objects in memory, can and should used predefined abstract types such as size_t.

It's often incorrectly assumed that C's types are defined to have certain, exact sizes. In fact, what's guaranteed is that:

type char can hold values up to 127;
types short int and int can hold values up to 32,767; and
type long int can hold values up to 2,147,483,647.

something like the relation

	sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long)

holds. [footnote]

From these values, it can be inferred that char is at least 8 bits, short int and int are at least 16 bits, and long int is at least 32 bits. (The signed and unsigned versions of each type are guaranteed to have the same size.) Under ANSI C, the maximum and minimum values for a particular machine can be found in the header file ; here is a summary:

Base type	Minimum size (bits)	Minimum value (signed)	Maximum value (signed)	Maximum value (unsigned)
`char`	8	-127	127	255
`short`	16	-32,767	32,767	65,535
`int`	16	-32,767	32,767	65,535
`long`	32	-2,147,483,647	2,147,483,647	4,294,967,295

(These values are the minimums guaranteed by the Standard. Many implementations allow larger values, but portable programs shouldn't depend on it.)

If for some reason you need to declare something with an exact size (usually the only good reason for doing so is when attempting to conform to some externally-imposed storage layout, but see question 20.5), be sure to encapsulate the choice behind an appropriate typedef, but see question 1.3.

If you need to manipulate huge values, larger than the guaranteed range of C's built-in types, you need an arbitrary-precision (or ``multiple precision'') arithmetic library; see question 18.15d.

Yama的家 2006-03-09 09:41 发表评论

关于C99翻译募集（自由参加，free学习）

Yama的家 — Fri, 03 Mar 2006 03:05:00 GMT

一直想腾出时间来好好把C99全部翻译出来，很多地方看过了但是用中文表达的确很难以描述。所以
想到集众人的力量来好好翻译一下，请希望学习和我一样对C报有兴趣的人来参加。
因为不是盈利项目，如果你实在没有时间也不要紧。期待大家的参加，最好是7月底前能够完成。
希望一个人负责一节左右，看过c99英文式样的人都知道关键是第6章和第七章。

1。我的邮件是chinatimeover@hotmail.com(来信请注明c99,当然别的朋友也欢迎，不过最近很忙，如果不能回信请见谅)
2。所有的人可以在自己的blog上翻译，但是务必mail给我（成果物按周提交，我会对它和检查。不能按时完成任务请注明。）
3。我会开2篇文章，每周发布一次。对于参加的每位成员我也会单独把成果以mail形式转送
一篇是用到的术语统一名称贴，一篇是成果物贴（我会注明翻译者的名字）
4。募集准备到本月为止，然后我会再次发布任务分配，如果你对于C99有过很好的研究，可以注明你希望翻译的章节（也许有人翻译过，但是就目前网上看很多翻译的作品离我想象得太远，特别是上次的RFC翻译事件，老实说很多文章和英文版有差距）
5。声明C99英文版是有版权的，所以我们的作品仅仅是为了学习，没有任何营利目的，如果侵害到某某版权问题，请来信告知，我会妥善处理。所以不要找我要求c99文档-〉下载有的我调查过，嘻嘻。
6。翻译和校对时间 4，5，6三个月（视情况决定）。最后再次希望社区内的大拿们鼎力协作。把我们blog社区办的更有影响力

心无尘土

20060303

Yama的家 2006-03-03 11:05 发表评论

extern

Yama的家 — Wed, 11 Jan 2006 06:38:00 GMT

extern是C/C++语言中表明函数和全局变量作用范围（可见性）的关键字.
它告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。
1。对于extern变量来说，仅仅是一个变量的声明，其并不是在定义分配内存空间。如果该变量定义多次，会有连接错误
2。通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字extern声明。也就是说c文件里面定义，如果该函数或者变量与开放给外面，则在h文件中用extern加以声明。所以外部文件只用include该h文件就可以了。而且编译阶段，外面是找不到该函数的，但是不报错。link阶段会从定义模块生成的目标代码中找到此函数。
3。与extern对应的关键字是static，被它修饰的全局变量和函数只能在本模块中使用。

后面转载，阅读中。。。。。。。
　　被extern "C"修饰的变量和函数是按照C语言方式编译和连接的；
未加extern “C”声明时的编译方式

　　首先看看C++中对类似C的函数是怎样编译的。

　　作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在符号库中的名字与C语言的不同。例如，假设某个函数的原型为：

void foo( int x, int y );

　　该函数被C编译器编译后在符号库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“mangled name”）。

　　_foo_int_int这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。例如，在C++中，函数void foo( int x, int y )与void foo( int x, float y )编译生成的符号是不相同的，后者为_foo_int_float。

　　同样地，C++中的变量除支持局部变量外，还支持类成员变量和全局变量。用户所编写程序的类成员变量可能与全局变量同名，我们以"."来区分。而本质上，编译器在进行编译时，与函数的处理相似，也为类中的变量取了一个独一无二的名字，这个名字与用户程序中同名的全局变量名字不同。

　　未加extern "C"声明时的连接方式

　　假设在C++中，模块A的头文件如下：

// 模块A头文件　moduleA.h
#ifndef MODULE_A_H
#define MODULE_A_H
int foo( int x, int y );
#endif

　　在模块B中引用该函数：

// 模块B实现文件　moduleB.cpp
#include "moduleA.h"
foo(2,3);

　　实际上，在连接阶段，连接器会从模块A生成的目标文件moduleA.obj中寻找_foo_int_int这样的符号！

　　加extern "C"声明后的编译和连接方式

　　加extern "C"声明后，模块A的头文件变为：

// 模块A头文件　moduleA.h
#ifndef MODULE_A_H
#define MODULE_A_H
extern "C" int foo( int x, int y );
#endif

　　在模块B的实现文件中仍然调用foo( 2,3 )，其结果是：

　　（1）模块A编译生成foo的目标代码时，没有对其名字进行特殊处理，采用了C语言的方式；

　　（2）连接器在为模块B的目标代码寻找foo(2,3)调用时，寻找的是未经修改的符号名_foo。

　　如果在模块A中函数声明了foo为extern "C"类型，而模块B中包含的是extern int foo( int x, int y ) ，则模块B找不到模块A中的函数；反之亦然。

　　所以，可以用一句话概括extern “C”这个声明的真实目的（任何语言中的任何语法特性的诞生都不是随意而为的，来源于真实世界的需求驱动。我们在思考问题时，不能只停留在这个语言是怎么做的，还要问一问它为什么要这么做，动机是什么，这样我们可以更深入地理解许多问题）：

　　实现C++与C及其它语言的混合编程。

　　明白了C++中extern "C"的设立动机，我们下面来具体分析extern "C"通常的使用技巧。

　　4.extern "C"的惯用法

　　（1）在C++中引用C语言中的函数和变量，在包含C语言头文件（假设为cExample.h）时，需进行下列处理：

extern "C"
{
#include "cExample.h"
}

　　而在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern "C"声明，在.c文件中包含了extern "C"时会出现编译语法错误。

　　笔者编写的C++引用C函数例子工程中包含的三个文件的源代码如下：

/* c语言头文件：cExample.h */
#ifndef C_EXAMPLE_H
#define C_EXAMPLE_H
extern int add(int x,int y);
#endif
/* c语言实现文件：cExample.c */
#include "cExample.h"
int add( int x, int y )
{
　return x + y;
}
// c++实现文件，调用add：cppFile.cpp
extern "C"
{
　#include "cExample.h"
}
int main(int argc, char* argv[])
{
　add(2,3);
　return 0;
}

　　如果C++调用一个C语言编写的.DLL时，当包括.DLL的头文件或声明接口函数时，应加extern "C" {　}。

　　（2）在C中引用C++语言中的函数和变量时，C++的头文件需添加extern "C"，但是在C语言中不能直接引用声明了extern "C"的该头文件，应该仅将C文件中将C++中定义的extern "C"函数声明为extern类型。

　　笔者编写的C引用C++函数例子工程中包含的三个文件的源代码如下：

//C++头文件 cppExample.h
#ifndef CPP_EXAMPLE_H
#define CPP_EXAMPLE_H
extern "C" int add( int x, int y );
#endif
//C++实现文件 cppExample.cpp
#include "cppExample.h"
int add( int x, int y )
{
　return x + y;
}
/* C实现文件 cFile.c
/* 这样会编译出错：#include "cExample.h" */
extern int add( int x, int y );
int main( int argc, char* argv[] )
{
　add( 2, 3 );
　return 0;
}

　　如果深入理解了第3节中所阐述的extern "C"在编译和连接阶段发挥的作用，就能真正理解本节所阐述的从C++引用C函数和C引用C++函数的惯用法。对第4节给出的示例代码，需要特别留意各个细节。

Yama的家 2006-01-11 14:38 发表评论

C99-2

Yama的家 — Wed, 07 Dec 2005 07:29:00 GMT

摘要: 从我的csdn的小窝转过来
c99 2.术语，定义，符号
阅读全文

Yama的家 2005-12-07 15:29 发表评论

C99-1

Yama的家 — Wed, 07 Dec 2005 07:25:00 GMT

标准才是最重要。我们的目标是创造新的标准。

c99(ISO/IEC 9899：1999 international stardard)，他的前一个版本是ISO/IEC 9899：1990

1.范围

C99定义了以下的内容

-C程序的表现法

-关于C语言的语法和约束限制

-编译C程序的语义规则（YamaC99文档之所以收费，估计就是因为它了Yama）

-关于C语言处理入力数据的说明

-关于C语言产生出力数据的说明

-利用约束和限制的状态一致的C的执行

C99没有说明的内容

-C程序被用来转化成数据处理系统的机制

-C程序被应用于数据处理系统的机制

-通过C程序转化入力数据的机制

-入力数据通过C程序产生后转化的机制

-程序的大小和复杂度。数据超过特有的数据处理系统或者特殊处理器的处理能力

-一个数据处理系统的所有最小划分要求都能够支持一致性执行

Yama的家 2005-12-07 15:25 发表评论