本文作者：黄邦勇帅
本文是学习C++最基础的内容，因此应对其熟练掌握，本文主要介绍了声明与定义的区别，C++中有关变量及数据类型的描述，其中由浅入深的介绍了复杂声明的分析方法，本文内容由浅入深，内容较为全面。
本文内容完全属于个人见解与参考文现的作者无关，其中难免有误解之处，望指出更正。
声明：禁止抄袭本文，若需要转载本文请注明转载的网址，或者注明转载自“黄邦勇帅”。
主要参考文献：
1、C++.Primer.Plus.第五版.中文版[美]Stephen Prata著孙建春韦强译人民邮电出版社2005年5月
2、C++.Primer.Plus.第四版.中文版Stanley B.Lippman、Barbara E.Moo著李师贤等译人民邮电出版社2006年3月
3、C语言：标准与实现volume 1 作者不详，前言是“姚新颜”写的可能就是作者，出版社不详，2004年8月
4、《程序设计语言C》中华人民共和国国家标准GB/T 15272-94 1994年12月7日发布出版社不详
5、《C++程序设计原理与实践》[美]Bjarne Stroustrup著王刚刘晓光吴英李涛译机械工业出版社2010年6月
6、《C++程序设计语言》特别版[美]Bjarne Stroustrup著裘宗燕译机械工业出版社2010年3月
7、《C和指针》第二版[美] Kenneth A.Reek著徐波译人民邮电出版社出版日期不详
8、《C陷阱与缺陷》Andrew Koenig 著高巍译王昕审校人民邮电出版社出版日期不详
9、《C专家编程》作者、出版社、出版日期不详
10、《C语言核心技术》Peter Prinz εTony Crawford著O’Reilly Taiwan公司译机械工业出版社2007年8月
11、《ANSI C标准详解》作者、出版社、出版日期不详
第3部分声明、定义、变量、数据类型专题
关键概念
1、对象：指的是某种类型所占据的一片连续的内存单元，注意：对象不仅仅指的是一片连续的内存单元，而且这片内
存区域已经指定了某种类型。
2、标识符：标识符就是一个名字，使用标识符主要是与C++中的关键字相区别，本文所讲的名字和标识符都是指的标
识符。
一、变量、类型简单理解请参考《C++整型、字符型、浮点型专题》相关内容。
二、变量、对象、实体深度理解
1、注意：本文中的对象与类的对象是两个概念，应区别对待。
2、对象：指的是某种类型所占据的一片连续的内存单元，注意：对象不仅仅指的是一片连续的内存单元，而且这片内
存区域已经指定了某种类型。
3、变量：变量其实就是命名后的对象，也就是说变量是为指定类型的连续的内存单元(即对象)取的一个名字。一块连
续的内存单元，若我们使用内存的地址编号来访问这块内存单元，这样会让程序很难让人理解，因此就有必要为一块保存特定类型的连续的内存单元(即对象)取一个名字，这个名字就是我们所说的变量。
4、实体：本文中所说的实体就是变量的另一个名字，一般情况下变量指的是像整型，浮点型这些类型的对象，按变量
的概念，变量还可以是函数名，指针名，数组名等，为了描述方便，有时会使用实体一词。
5、从以上概念可以看出，变量、对象和实体三者的没有什么本质的区别。
三、类型深度理解
1、类型与内存
内存中的比特值的含义完全决定于这块内存单元所表示的类型，保存在计算机中的值是一些二进制比特，这些二进制比特对于计算机来讲，它并不知道代表什么意义，只有当我们决定如何解释这些比特时才有意义，比如65或字符’a’在内存中的比特值是相同的，若将比特值解释为int型，则他是一个十进制数，若解释为char型，则是这符a，因此在内存单元中的数据应具有一个类型，当类型确定后就能对其中的数据作出正确的解释了。
2、类型的作用
1)、类型决定了可以将什么数据赋给对象(比如整数3可以赋给int型，”dd”可以赋给string型等)
2)、类型决定了可以对该对象进行什么样的操作(比如可以对int型的变量或常量进行加、减、乘、除等操作，不能
进字符串变量或常量进行加、减、乘、除等操作)。
3)、类型还决定了对象的内存大小、布局和取值范围
3、每个名字(或变量，变量就是命名后的对象，因此一个变量就是一个名字)、表达式都应有一个类型，这个类型决定
了可以对这个名字进行什么样的操作，因此类型决定了这个名字或表达式的使用方式。
4、不能对变量赋予一个类型错误的值。
5、编译器会记录每个变量的类型，并确认对它进行的操作是否与类型相一致。
四、声明与定义
1、声明是一条语句，声明为对象起了一个名字，同时为名字确定了一个类型。
2、声明的作用：
1）、C++使用声明语句来告诉编译器一个对象的名字，比如int x;表示x是一块类型为int的内存区域的名字。
2）、C++使用声明语句告诉编译器一个对象是什么类型。比如语句int x;就能告诉编译器变量x的类型为int型。一个命名的对象必须有一个类型，有了具体的类型我们才能确定对对象作出什么样的操作，对象能够接收什么样的值等，C++使用声明语句来实现此目的。
3、定义：定义是一个声明，同时定义会为对象分配内存空间，因此定义也是一个声明。
五、声明与定义的区别及注意事项
1、C++中的名字(标识符)必须先声明后再使用，也就是说在使用前必须先确定它的类型，以通知编译器这个名字所引
用的是什么类型的实体。
2、对同一个名字只能定义一次，因为定义为命名对象(比如变量，函数名等)分配了内存，同一名字的对象只能分配一
个内存位置，所以只能定义一次。
3、对同一个名字的声明可以有任意多次。
4、对同一个名字的所有声明必须具有相同的类型。
5、区别声明与定义的方法：就是在程序中对同一个标识符声明多次，若语句不出错，则是声明，若出错，则是定义，
比如extern int a; extern int a;程序不会出错，因此是声明，而int a; int a;则会出错，因此是定义。注：变量的声明与定义详见后文。
5、任何进行了初始化操作的语句都是定义。
6、每个定义都是一个声明，但声明未必是定义。
7、非定义的声明仅仅告诉编译器程序中有这么一个具有指定类型的名字，因此声明不会为对象分配内存(比如为变量
分配内存，为函数指定函数体)。
8、对于变量来说，其声明只说明了类型，而定义则会为该变量分配存储空间。
9、对于函数来说，声明也提供了类型(即参数类型和反回类型)，而定义才会提供函数体(即{}括起来的部分)。
10、注意：函数体是被作为程序的一部分而被保存在内存中的，因此函数和变量的定义都消耗了内存，而声明则没有。
11、注意：在声明时，在名字后带一对空的小括号程序会认为这是一个函数，而不是对类调用的默认构造函数(详见后
文)，比如hy g(); 其中hy是一个类类型(即class hy{...})，语句hy g();只是表明是对一个函数的声明，而不会是使用默认构造函数创建一个类类型的对象g。
六、声明的语法形式
声明的形式为：[ [存储类区分符] | [类型限定词] ] <类型区分符> 声明符[, 声明符[, 声明符[, ....]];
说明：
1、方括号”[]”中的内容表示可选项，以短竖线”|”隔开的内容可以只选一项，尖括号<>中的内容是必选项。
2、存储类区分符有：extern , static, auto, register。其中extern表示外部的，static表示静态的，auto表示自动，register
表示寄存器，存储类区分符请参看语句与作用域部分内容，本文不深入讨论。
3、类型限定词有2个：const, volatile。其中const一般被理解为只读，而volatile则是易变。
4、类型区分符有：基本类型(如int, float, double, unsigned long int等)；void类型；枚举、结构或联合类型；用户自定义
类型；
5、声明符：
1)、声明符可以有多个，多个声明符之间使用逗号相隔开。
2)、有5种不同的声明符，即标识符，函数声明符()，数组声明符[]，指针声明符*，引用声明符&；根据声明符的
不同，我们可以声明不同的对象。
3)、若声明符就是一个标识符，则标识符会被声明为一个变量。
4)、函数声明符()：若标识符后跟一对圆括号的情形，圆括号内可能有形参表，则这时标识符将被声明为一个函数，
比如int f(float);就表示标识符f是一个反回类型为int带有一个float形参的函数。
5)、数组声明符[]：若标识符后跟一对方括号，方括号内是任选的常量表达式，则这时标识符将被声明为一个数组，
比如int a[11]; 表示标识符a是一个int型数组。
6)、指针声明符*：若在标识符的前面有一个星号”*”，在星号和标识符之间可能会有类型限定词，则这时标识符将
被声明为一个指针，比如int *p; 表示标识符p是一个int型指针；再如int *const p; float *p; 等。
7)、引用声明符&：若在标识符的前面有一个符号”&”，则这个标识符将被声明为一个引用，比如int &b;表示标识
符b被声明一个类型为int的引用。
七、声明的规则和限制
1、注意：声明语句后面有一个分号，分号表示此声明语句到此结束。C++中的语句详见后文
2、在一个声明中最多只能有一个存储类区分符，即extern , static, auto, register只能有其中一个。
3、一个标识符必须指定一个类型，且只能指定一种类型，也就是说不能让一个变量即是int型又是float型。注意：C
语言中可以不为标识符指定类型，比如const x;将是一个声明(缺省为int型)，但C++必须为标识符指定类型，C++没有缺省的类型。
4、可以使用多个相同或不同的类型限定词(即const和volatile)，顺序不关紧要，编译器会忽略相同的多余的限定词。
5、存储类区分符，类型限定词，类型区分符必须在标识符的前面，三者之间的顺序不关紧要。
6、若函数是类中的一个成员时，类型限定词const和volatile可以出现在函数名的后面，注意：类的成员变量不能将
const放在变量名的后面，类的内容具体参见相关内容。
7、声明符中的()、[]应放在标识符的后面，*、&、*const应放在标识符的前面，且()与[]优先级相同，()和[]比*和&优
先级更高。
8、注意：*可以放在类型限定词const和volatile的前面，但不能放在类型区分符(如int, float等)和存储类区分符(如auto,
extern等)的前面。
9、函数的反回值不能是一个函数，但反回值可以是一个函数指针，比如int f()();是非法的，int (*f())()是正确的。
10、函数的反回值不能是一个数组，但反回值可以是一个指向数组的指针，比如int f()[]是错误的，int (*f())[];是正确的。
11、数组里面的元素不能有函数，但数组里面可以有函数指针，即int f[]()是不正确的，int (*f[])();是正确的。
12、在数组里面可以有其他数组，即我们经常见到的二维数组int f[][];是正确的。
13、使用声明语法可以产生很复杂的声明，比如int *const volatile *(*f)();等，复杂声明的类型的判断方法，本文后面会
做详细介绍。
14、关于指针，函数，数组的内容将在相应章节详细介绍，在理解声明时不必知道函数，指数，数组是什么，我们只
需知道他们的形式即可，即在标识符后有方括号是数组，比如a[]，在标识符后有圆括号是函数，比如f()，在标识符前有星号是指针，比如*p等。
15、注意：在C中声明时的类型区分符也是可选项，因此像const a;这样的语句是合法的，但在C++中这样的语句是错
误的，在C语言中支持默认的int类型，即const a;语句中的变量a将默认为int型，但C++不再支持默认int类型，默认int型经常是发生错误的开始。
八、变量的声明、定义及初始化、赋值
1、注意：此节所讲的变量不包括函数，指数，数组，关于函数、指针、数组的声明与定义详见相关章节。
2、对于变量来说未使用extern关键字的声明是一个定义，因此会为变量分配内存空间，
3、注意：声明或定义在语句的未尾有一个分号，比如int a;后面有一个分号，C++使用分号表示对一个简单语句的结束。
4、初始化：就是指在定义变量时给出变量的初始值，比如int a=1;表示将变量a的值初始化为1，这时变量a变拥有值
1。
5、两种初始化变量的形式：即复制初始化和直接初始化。使用这两种初始化方法的原因是是C++在创建类的对象时会
有这两种初始化方法，而且他们是有一定差别的，但对于内置类型变量来讲不会有什么差别。
6、复制初始化：就是在定义时使用赋值运算符(即”=”)进行的初始化，比如int a=1; float b=2.0;就是复制初始化。
7、复制初始化有两种形式：第一种使用表达式，比如int a=1; int b=2+3;等，第二种使用初始化列表(即使用大括号)的
形式，初始化列表就是将各个表达式放在大括号中，表达式之间使用逗号隔开，这种形式一般用于初始化数组；示例int a={1}; int b={2+3}; int c[2]={1,2+3};有关数组的初始化请参看数组相关部分内容。
8、注意：使用初始化列表初始化时，大括号中的表达式在C++标准中是以逗号结尾的，当然也可省略，因此int c[]={1,3,};
是正确的初始化语法。
9、直接初始化：是指在定义时将值放在变量名后的一对小括号中，比如int a(1); 将把变量a的值初始化为1，
10、注意：在直接初始化时，变量名后的括号不能为空值，若为空值则表示的是声明一个反回指定类型的无参函数，
比如int a(); 表示声明的是一个反回int型的没有形参的函数，而不是在定义一个变量a。
11、复制初始化与赋值的区别：复制初始化使用赋值运算符”=”对变量进行初始化，会让人以为初始化时就是在赋值，
其实初始化与赋值是有区别的，它们的区别在于，初始化是在创建变量的时候给他一个初始值，而赋值则是发生在变量已经创建之后进行的擦除旧值写入新值的操作。比如int a; a=2; 就是赋值，语句int a;定义了一个变量，并为变量分配了存储空间，这时变量已经拥有一个值，若为局部变量(有关局部变量见相关内容)则这个值是随机的，然后a=2; 将变量a的随机值擦除，并将新值2写入到变量a中；而int a=2; 则是在创建变量a时(这时变量a还没有值)就将变量a的值初始化为2了。
12、若是在函数体外定义的或使用static定义的内置类型变量都会自动初始化为0，若是在函数体内定义的内置类型变
量则不会对其进行初始化，这时变量虽没有初始化，但不代表变量就没有值，编译器一般都会为变量产生一个随机值，若在程序中使用了这种变量将会导致一个难以发现的错误，因此建义对内类型变量最好都要初始化，然后再使用。
13、变量的非定义声明：若使用extern来声明变量，同时没有初始化变量，则是对变量的一个非定义的声明，extern
表明此变量在程序中的其他地方有定义或者在其他文件中有定义；比如extern int i; 表示声明一个变量名为i类型为int的变量，此变量在其他地方有定义。
14、非定义声明变量的条件：1、使用extern关键字；2、变量没有初始化。比如extern int x;表示声明一个变量x，而
int y;因为没有使用extern关键字，因此语句不是一个非定义的声明，同理extern int z=1; 这里对变量进行了初始化，
因此同样不是一个非定义的声明。
15、注意：使用extern关键字声明变量时不能在函数内对其进行初始化，比如void f(){extern int a=1;}将会得到一个错
误。
16、非定义声明变量与定义的区别：使用extern对变量进行的是一个非定义的声明，因为变量没有定义，因此可以对
变量进行多次声明，而定义，则只能进行一次。
17、声明(或定义)和初始化多个变量：要声明多个变量只需要在每个变量名之间使用逗号隔开即可，比如int a,b,c; 再
如extern int a,b,c;要对声明的多个变量进行初始化，只需在要初始化的变量使用初始化的方法即可，比如int a, b=2, c; 再如int a=1,b=2,c=3;等。
九、使用类型限定词(const和valatile关键字)声明或定义变量
1、可以使用多个相同或不同的类型限定词(即const和volatile)，顺序不关紧要，编译器会忽略相同的多余的限定词。
2、若变量使用const限定词，则该变量就是常量或是只读的，在定义该变量后，就无法修改变量的值。
3、volatile限定词，表示变量可能会被其他程序或事件所修改。因为其他程序或事件可能修改其值，因此volatile关键
字还告诉编译器，在每次使用该变量时，都要要进行重新读取。
4、编译器可将非volatile类型的const对象放在只读存储区，若从不使用它，则编译器有可能不会为该变量分配内存。
5、若变量同时使用const和volatile限定，则此变量无法被程序本身所修改，但可以被其他程序或硬件修改。
6、使用const声明常变量时，const关键字与类型区分符的顺序无关紧要，比如int const a=1;与const int a=1;是等价的。
7、使用const声明的变量必须进行初始化，因为使用const后是一个常量，其值无法在以后使用赋值运算符进行修改，
因此在声明时必须进行初始化。
8、volatile限定词很少被使用，因此不重点介绍。
十、复杂声明
1、声明之所以复杂主要是由于*、[]、( )这3种运算符的作用，才使声明变得很复杂，其中*表示指向....的指针，()表示
反回类型为....的函数，[]表示....的数组。
2、*是前缀运算符，()和[]是后缀运算符，前缀运算符只能出现在标识符的前面，而后缀运算符则只能出现在标识符的
后面，比如int [22]a; int b*; int *[]c; 是错误的。
3、复杂声明的分析方法
1)、首先应从标识符(就是名字)开始分析。
2)、声明中被小括号”()”括起来的内容，优先级最高，若小括号有多层，则最里层的优先级最高，小括号不会与函
数运算符的小括号相混淆，这从语句中可以明显的看出来。
3)、反缀运算符具有相同的优先级，当有多个后缀运算符时，则应按从左到右的顺序进行分析。
4)、后缀运算符比前缀运算符优先级高。当有多个前缀运算符时，应按从右到左的顺序进行分析。
5)、有const和volatile限定词时，若const或volatile后面紧接着的是类型区分符(如int, float等)，则限定词将作用
于类型区分符，否则，限定词将作用于它左边紧邻的指针运算符(即星号”*”)。
6)、若与标识符第一个接合的运算符是一个指针符号*，则该标识符就是指向....的指针，也就是说标识符就是一个
指针，只是这个指针指向的内容可能很复杂。比如int (*b)[]; 标识符b先与*接合，因此b是一个指针，这个指针指向的是一个数组，再如int *(*b)();表示b是一个指针，这个指针指向的是一个反回类型为int *的函数。
7)、若与标识符第一个接合的是数组下标运算符[]，则该标识符是....的数组，也就是说这个标识符一定是个数组，
只是数组里存储的内容可能很复杂。比如int *a[]; 因为[]优先级更高，因此标识符a先与[]接合，因此标识符a 是一个数组，这个数组里的内容是int *的指针；
8)、若与标识符第一个接合的是函数符()，则该标识符是反回....的函数，也就是说这个标识符就是一个函数，只是
这个函数的反回类型可能很复杂。int (*f())[];表示f是一个函数，这个函数反回的是一个指针，这个指针指向的是一个数组。
4、示例：const int *const (*f())[];
1）、从标识符f开始分析，标识符首先与()结合，说明f是一个函数。
2）、再按优先级规则，分析小括号内的内容，与指针*结合，因此函数f反回的是一个指针。
3）、再与[]结合，说明函数f反回的指针指向的是一个数组。
4）、再分析const限定符，因为const后不是类型区分符，因此const与左边紧邻的*接合，说明函数f反回的指针指向的是一个数组，这个数组里的内容是一个常量指针。
5）、最前一个const后紧接一个类型区分符int，因此const与int接合，最后说明函数f反回的指针指向的是一个组数，数组里的内容是一个常量指针，且这个指针指向的是cont int类型的常量。
5、复杂声明的类型：
1)、声明时的类型用于强制类型转换时可能会有用；在复杂声明时，声明的类型就是将声明时的标识符去掉即可，
比如const int *const (*f())[];其类型就是const int *const (*())[];表明这是一个函数类型；
2)、若要知道函数反回的类型，则应将代表函数的小括号去掉，比如const int *const (*f())[];其函数反回的类型就是
const int *const (*)[];表明函数反回的是一个指针。
示例：声明的规则和限制、变量的声明和定义、复杂声明
#include
using namespace std;
//a1=2; //错误，标识符必须先声明后使用。
int a2; //未使用extern的变量声明同时是一个定义，因此此语句会为变量分配内存空间。
//int a2; //错误，同一变量只能定义一次。
extern int a3; //这是对变量的非定义声明，使用extern关键定，而且未初始化。
extern int a3; //正确，可以对同一个标识符声明多次。
//extern long int a3; //错误，对同一标识符的多次声明必须要有相同的类型。
extern int a5=2; //任何进行了初始化的语句都是一个定义。
//extern auto int a6; //错误，在声明时只能指定一个存储类区分符，即auto, extern ,static, register之中只能有一个。
//const a7; //错误，C++中必须为标识符指定类型区分符(比如int, float等)，这种语句在C语言中是正常的，因为C支持默认的int型。
const const volatile int a8=8; //正确，声明中可以使用多个相同或不同的类型限定词，对于多于的相同类型限定词编译器会忽略。若变量同时使用const和volatile限定，则此变量无法被程序本身所修改，但可以被其他程序或硬件修改。注意：const常量必须初始化。
//int a9 auto; //错误，存储类区分符应在标识符的前面。
//int a10 const; //错误，类型限定词应出现在标识符的前面，但在类中声明的是成员函数时除外。
class A{void f1() const;}; //在类中声明的是成员函数时可以将类型限定词放在函数名的后面，注意：只有函数名才是正确的，对于变量名将会出错。
//int []a11; //错误，()、[]运算符，在声明时必须放在标识符的后面，这种语句在java中是允许的。
//int a12*; //错误，声明时*、&、*const必须放在标识符的前面。
//int *static a13; //错误，*不能放在类型区分符(如int, float等)和存储类区分符(如auto, extern等)的前面
int*const a14=0; //正确，*可以放在类型限定词的前面，这时类型限定词限定的是左边的*(即指针)，注意：const常量必须初始化。
//int f2()(); //错误，函数不能反回函数。
int(*f3())(); //正确，函数的反回值可以是一个指向函数的指针，函数f3反回一个指针，这个指针指向一个函数。
//int f4()[]; //函数的反回值不能是一个数组。
int(*f5())[]; //正确，函数的反回值可以是一个指向数组的指针。函数f5反回一个指针，这个指针指向的是一个数组。
//int a15[](); //错误，数组中的元素不能是函数。
int(*a16[])(); //正确，数组中的元素可以是一个指向函数的指针。
int a17[][11]; //正确，数组中的元素可以是一个数组，这就是普通的二维数组，注意：声明二维数组时第二个[]必须指定一个常量值。
int a18=18; //变量的复制初始化语法之一。
int a19={19}; //使用大括号{}对变量进行复制初始化，此方法一般用于声明有多个元素的数组，
int a20[]={1,2,}; //使用大括号{}一般用于初始化有多个元素的数组，每个值之间使用逗号隔开，且以逗号结束，当然也可以省略最后的那个逗号。
int a21(21); //变量的直接初始化方法，就是在变量名后紧跟小括号并在其中指定初始值。
int a22(); //注意：直接初始化时，变量名后的括号不能为空值，若为空值则表示的是声明一个反回指定类型的无参函数，因此这里表示的是声明一个反回int类型的无参函数，这里不是在使用直接初始化方式初始化变量。
int a23; //在函数体外定义的变量会被自动初始化为值；
void main()
{int b1,b2,b3=33,b4,b5=3; //同时声明或初始化多个变量时使用逗号隔开
//extern int a24=3; //错误，在函数内部不能对使用extern声明的变量进行初始化。
extern int a23; //extern表明此变量在程序中的其他地方有定义或者在其他文件中有定义，这里a23在函数体外被定义了。
int a25; // 在函数体内定义的内置类型变量则不会对其进行初始化，编译器一般都会为变量产生一个随机值。
//复制初始化与赋值区别：初始化是在创建变量的时候给他一个初始值，而赋值则是发生在变量已经创建之后进行的擦除旧值写入新值的操作。
int a26=26; //这是复制初始化，这是在创建变量a25时(这时变量a25还没有值)就将变量a26的值初始化为了
a26=261; //这是赋值，表示将变量a26的旧值擦除，并将新值写入到变量a26中。
//a8=8; //错误，不能对常量a8的值进行修改。
const int*const(*f())[]; //一个复杂声明，复杂声明时，首先从标识符开始按照优先级规则进行分析，具体参看正文。
int*p;
(const int*const(*)[])p; //复杂声明的类型判断一般用于强制类型转换。
system("pause");}
作者：黄邦勇帅(2012年3月)
本题序号：118 当定义一个结构体变量时，系统分配给它的内存大小的理论值是__________。 A 各成员所需内存的总和 B 结构体中的第一个成员所需内存 C 成员中所需内存最大者的存储空间 D 结构体中的最后一个成员所需存储容量参考答案 A 本题序号：165 存放多个字符串，用________比较适合。 A 二维字符数组 B 一维字符数组 C 自定义结构体 D 自定义联合体 参考答案 A 本题序号：169 定义生成非静态变量时，将对变量进行_______。 A 自动赋初值 B 自动赋0 C 不会自动赋初值 D 自动赋-1 参考答案 C 本题序号：180 x为int型，s为float型,x=3,s=2.5。表达式s+x/2的值为________。 A 4 B 3.5 C 2.5 D 3 参考答案 B 本题序号：182 x、y为整数，x=15,y=-2。表达式x>10 and y<2 or x*y==10 and x的值为_________。 A 0 B 15 C 1 D 2 参考答案 C 本题序号：211 以下定义， struct st1{int a,b;float x,y;}; struct st2{int a,b;st1 s1; } ss; 对成员变量x的引用形式正确的是：_________ 。 A ss.s1.x B st2.st1.x C st2.s1.x D ss.x 参考答案 A 本题序号：215 对任意整型数据数据m,n(m>n>0), 则 C 语言表达式m-m/n*n的值为：_______________。 A 0 B m%n C 1 D n%m 参考答案 B 本题序号：223 设有以下定义： enum t1 {a1,a2=7,a3,a4=15} time; 则枚举常量a1和a3的值分别是 A 1和2 B 6和3 C 1和8 D 0和8 参考答案 D 本题序号：225 设有类型说明：enum color{red,yellow=3,white,black}; 则执行语句cout< 第7章自定义数据类型习题 一．选择题： 1．当定义一个结构体变量时，系统分配给它的内存空间是【】。 A) 结构中一个成员所需的内存量B) 结构中最后一个成员所需的内存量 C) 结构体中占内存量最大者所需的容量D) 结构体中各成员所需内存量的总和2．若有以下说明，对初值中整数2的正确引用方式是【】。 static struct { char ch； int i； double x； } a[2][3]={{…a?,1,3 .45,?b?,2,7.98,?c?,3,1.93I} {…d?,4,4.73,?e?,5,6.78,?f?,6,8.79 }}； A) a[1][1].i B) a[0][1].i C) a[0][0].i D) a[0][2].i 3．根据以下定义，能打印字母M的语句是【】。 struct p { char name[9]； int age； }c[10]={“Jobn”,17,”Paul”,19,”Mary”,18,”Adam”,16}； A) printf(“％c”，c[3].name)；B) printf(“％c”，c[3].name[1])； C) printf(“％c”，c[2].name)；D) printf(“％c”，c[2].name[0])； 4．以下说明和语句中，已知int型数据占两个字节，则以下语句的输出结果是【】。 struct st { char a[l0]； int b； double c； }； printf(“％d”，sizeof(struct st))； A) 0 B) 8 C) 20 D) 2 5．以下说明和语句中，对结构体变量std中成员id的引用方式不正确的是【】。 struct work { int id； int name； } std, *p； p=&std； A) std.id B) *p.id C) (*p).id D) &std.id 6．如设有如下定义，若要使px指向rec中的成员x，正确的赋值语句是【】。 struct aa 变量 在将变量前，先解释一下声明和定义这两个概念。声明一个变量意味着向编译器描述变量的类型，但并不为变量分配存储空间。定义一个变量意味着在声明变量的同时还要为变量分配存储空间。在定义一个变量的同时还可以对变量进行初始化。 局部变量通常只定义不声明，而全局变量多在源文件中定义，在头文件中声明。 局部变量 在一个函数的内部定义的变量是内部变量，它只在本函数范围内有效。自动变量auto 函数中的局部变量，其缺省格式是自动变量类型。例如，在函数体中int b, c=3。和auto int b, c=3。是等价的。 自动变量是动态分配存储空间的，函数结束后就释放。自动变量如不赋初值，则它的值是一个不确定的值。 静态局部变量static 静态局部变量是指在函数体内声明和定义的局部变量，它仅供本函数使用，即其他函数不能调用它。静态局部变量的值在函数调用结束后不消失而保留原值，即其占用的存储单元不释放，在下一次函数调用时，该变量已有值，就是上一次函数调用结束时的值。 静态局部变量在静态存储区分配存储单元，在程序的整个运行期间都不释放。静态局部变量是在编译时赋初值的，即只赋初值一次。 在SDT编译器中，建议对静态局部变量赋初值，否则该静态局部变量的初值为不确定值。在其他编译器中，未初始化的静态局部变量的初值可能为零，这由具体的编译器所决定，使用前最好测试一下。 寄存器变量register 带register修饰符的变量暗示（仅仅是暗示而不是命令）编译程序本变量将被频繁使用，如果可能的话，应将其保留在CPU的寄存器中，以加快其存取速度。 对于现有的大多数编译程序，最好不要使用register修饰符。因为它是对早期低效的C编译程序的一个很有价值的补充。随着编译程序技术的进步，在决定哪些变量应当被存到寄存器中时，现在的C编译程序能比程序员做出更好的决定。 全局变量 在函数之外定义的变量称为外部变量，外部变量是全局变量，它可以为本文件中其他函数所共用。全局变量都是静态存储方式，都是在编译时分配内存，但是作用范围有所不同。 静态外部变量static 静态外部变量只能在本文件中使用。所以静态外部变量应该在当前源文件中声明和定义。 外部变量extern 定义函数中的全局变量时，其缺省格式是外部变量类型。外部变量应该在一个头文件中声明，在当前源文件中定义。外部变量允许其他文件引用。 若变量均已正确定义并赋值,以下合法的C语言赋值语句是(c)。 A、x+n=I; B、x==5; C、x=n/2.5; D、5=x=4+1; 下述错误的C语言常量是:( c). A、0xf B、5. C、090 D、.25 根据下面的程序,使a=123,c1='o',c2='k'哪一种是正确的键盘输入方法?(b )。(规定用字符串[CR]表示回车,U表示空格) main() {int a; char c1,c2; scanf("%d%c%c", &a,&c1,&c2); } A、123UoUk[CR] B、123ok[CR] C、123Uok[CR] D、123oUk[CR] 已知键入a=4,b=3,执行下面程序输出的结果是( b). main() { int a,b,s; scanf("%d%d",&a,&b); s=a; if(a>b) s=b; s=s*s; printf("%d\n", s); } A、13 B、9 C、16 D、15 执行下面程序段后,i的值是( a). int i=10; switch(i) {case 9: i+=1; case 10: i--; case 11: i*=3; case 12: ++i; } A、28 B、10 C、9 D、27 以下不是无限循环的语句为（d）。 A、while(1){x++;} B、for(;;x++=i); C、for(i=10;;i--) sum+=i; D、for(y=0,x=1;x>++y;x=i++) i=x 下面程序段运行的结果是(a ). x=-1; do{ x=x*x; }while (!x); A、循环执行一次 B、有语法错误 C、死循环 D、循环执行两次 若有说明:int a[][3]={1,2,3,4,5,6,7};则a数组第一维的大小是（a）。 A、3 B、无确定值 C、4 D、2 若定义int a[12]={1,2,3,4,5,6,7,8,9,10,11,12};char c='a',d,g; 则数值为4的表达式是 ( d). A、a[4] B、a[g-c] C、a['d'-'c'] D、a['d'-c] 以下叙述中正确的是（c）。 A、可以在一个函数中定义另一个函数 B、main()函数必须放在其它函数之前 C、构成C程序的基本单位是函数 D、所有被调用的函数一定要在调用之前进行定义 下述函数的功能是(c ). int fun(char *x) { char *y=x; while(*y++); return y-x-1; } A、比较两个字符串的大小 B、求字符串存放位置 C、求字符串的长度 D、将字符串x连接到字符串y后面 有关"文件包含"命令说法,下列叙述正确的是( a). A、将预处理的结果作为一个源程序编译,得到一个目标文件. B、一个 include 命令可指定多个被包含文件. C、将预处理的结果作为多个文件编译. D、被包含的文件可以是源文件或目标文件. 在声明语句:int *f();中，标识符f代表的是（a）。 A、一个返回值为指针型的函数名 B、一个用于指向函数的指针变量 C、一个用于指向一维数组的行指针 D、一个用于指向整型数据的指针变量 数据库系统原理实验报告 实验名称：__用户定义数据类型与自定义函数_ 指导教师：_叶晓鸣刘国芳_____ 专业：_计算机科学与技术_ 班级：__2010级计科班_ 姓名：_文科_____学号： 100510107 完成日期：_2012年11月10日_成绩： ___ ___一、实验目的： （1）学习和掌握用户定义数据类型的概念、创建及使用方法。 （2）学习和掌握用户定义函数的概念、创建及使用方法。 二、实验内容及要求： 实验 11.1 创建和使用用户自定义数据类型 内容： （1）用SQL语句创建一个用户定义的数据类型Idnum。 （2）交互式创建一个用户定义的数据类型Nameperson。 要求： （1）掌握创建用户定义数据类型的方法。 （2）掌握用户定义数据类型的使用。 实验 11.2 删除用户定义数据类型 内容： （1）使用系统存储过程删除用户定义的数据类型Namperson。 （2）交互式删除用户定义的数据类型Idnum。 要求： （1）掌握使用系统存储过程删除用户定义的数据类型。 （2）掌握交互式删除用户定义的数据类型。 实验 11.3 创建和使用用户自定义的函数 内容： （1）创建一个标量函数Score_FUN，根据学生姓名和课程名查询成绩。 （2）创建一个内嵌表值函数S_Score_FUN，根据学生姓名查询该生所有选课的成绩。 （3）创建一个多语句表值函数ALL_Score_FUN，根据课程名查询所有选择该课程学生的成绩信息。 要求： （1）掌握创建标量值函数的方法。 （2）掌握创建内嵌表值函数的方法。 （3）掌握创建多语句表值函数的方法。 实验 11.4 修改用户定义的函数 内容： （1）交互式修改函数Score_FUN，将成绩转换为等级输出。 （2）用SQL修改函数S_Score_FUN，要求增加一输出列定义的成绩的等级。要求： （1）掌握交互式修改用户定义函数的方法。 （2）掌握使用SQL修改用户定义函数的方法。 实验 11.5 输出用户定义的函数 内容： （1）交互式删除函数Score_FUN。 （2）用SQL删除函数S_Score_FUN。 要求： （1）掌握交互式删除用户定义函数的方法。 （2）掌握使用SQL删除用户定义函数的方法。 自定义数据类型 结构体 结构体是程序员在程序中自定义的一种数据类型，在说明和使用之前必须先定义它，也就是构造它。定义一个结构体的语法格式如下： Struct 结构体类型名 { 成员1的数据类型名成员1名称； 成员2的数据类型名成员2名称； . . 成员n的数据类型名成员n名称； }结构体变量表={成员初始化}； 注意成员可以由若干个不同的数据类型组成，每个成员也可以是结构体，即可以嵌套定义。 例如： Struct student { Long num; Char name; Char sex; Float score; }; 已经定义的某种结构体类型可以视为一种标准的数据类型，它的使用方法与标准数据类型使用方法相同，可以用来定义变量、数组、指针。 结构体变量说明 结构体变量的说明在程序的变量说明部分给出，一般在结构定义之后，它的语法格式如下： Struct 结构类型名结构变量名表； 例如： Struct student stu； 指出了结构变量stu是student类型的变量，它由四个成员组成，每个成员的数据类型和名字都与student结构定义中给出的相同。系统完全按照结构定义时制定的内存模式为结构变量分配内存空间。 可以在定义结构体类型的同时给出结构体变量。 Struct student { Long num; Cha name[20]; Cha sex; Float score; }stu1,stu2; 这种形式与前面给出的结构定义和结构说明分开处理效果相同。 结构体成员访问 结构体成员是通过结构体变量名和成员名进行访问的，不能把他作为一个整体进行访问。其访问格式如下： 结构体变量名.成员名 其中运算符.是成员访问运算符，其运算级别是最高的，和圆括号运算符()、下标运算符[]是同一级别的。如果结构体成员是指针变量，则访问格式为： *https://www.doczj.com/doc/428174622.html, 如果某个结构体变量的成员数据类型又是一个结构体，则访问方式为： 外层结构体变量名.外层成员名.内层成员名 可以在定义结构体变量的同时对结构体变量初始化。 {结构体成员}结构体变量={初始数据}； struct student { long num; char name[20]; char sex; float score; } stu1={200401L,"ZhangHong",'f',92.5f}; 对于嵌套的结构体类型数据，访问格式为： 结构体变量名1.结构体变量名2.成员名 结构体变量初始化的格式如下： struct 结构体名 {结构体成员}结构体变量={初始数据}； 初始数据类型必须与结构成员的数据类型相匹配，并且先后顺序一一对应赋值。 要对结构体变量的成员地址进行访问，其语法格式为： &结构体变量.成员名 当一个指针变量用来指向一个结构变量时，称为结构体指针变量。结构体指针变量中的值是所指向的结构体变量的首地址。 结构体指针变量： Struct 结构名*结构体指针变量名 Struct student *pstu; 必须先赋值后使用，把结构体变量的首地址赋给指针变量，不能把结构名或结构体变量名赋给指针变量。 pstu=&stu1; 结构体名和结构体变量是两个不同的概念，结构体名只能表示一个结构形式，编译系统并不对它分配内存空间，只有当某变量被说明为这种类型的结构时，才对该变量分配存储空间。这是因为结构体变量被定义后相当于标准数据类型被使用。 利用结构体指针变量访问成员如下： （*结构体指针变量）.成员名 或者： 结构体指针变量->成员名 后一种形式较为方便，容易区分。 1．变量的定义 从前面的章节可以看出，程序中所有的东西几乎都有名字。然而字面量却是个例外，它没有名字。那么使用变量，我们就可以为某个值取名字了。实际上，我们是为系统内存中用于保存数据的某块空间取名字。 ANSI C规定：变量必须“先定义、后使用”，因此当用C定义变量时，不仅需要指定变量名，而且还必须告诉编译器其存储的数据类型，变量类型告诉编译器应该在内存中为变量名分配多大的存储单元，用来存放相应变量的值（变量值），而变量仅仅是存储单元的别名，供变量使用的最小存储单元是字节（Byte）。 由此可见，每个变量都占据一个特定的位置，每个存储单元的位置都由“地址”唯一确定并引用，就像一条街道上的房子由它们的门牌号码标识一样。即从变量中取值就是通过变量名找到相应的存储地址，然后读取该存储单元中的值，而写一个变量就是将变量的值存放到与之相应的存储地址中去。 由于变量的定义不是可执行代码，因此要求局部变量的定义必须位于用“{}包围的程序块”的开头，即在可执行代码的前面。比如： int lower_limit = 80; //定义lower_limit为整型变量 即在定义lower_limit为int类型数据时，系统就已经为变量lower_limit分配了存储单元。请注意区分变量名和变量值这两个不同的概念，其中，lower_limit为变量名，80为变量lower_limit的值，即存放在变量lower_limit的存储单元中的数据。 那么到底如何获得变量的地址呢？C语言使用“&（地址运算符）加变量名”的方式获取变量的地址，比如，&lower_limit就代表变量lower_limit的地址，详见后续相关章节的描述。 一个定义只能指定一种变量类型，虽然后面所带的变量表可以包含一个或多个该类型的变量： int lower_limit , upper_limit , sum; 但如果将一个定义语句中的多个变量拆开在多个定义语句中定义的话： int lower_limit; // lower_limit为数据下限 int upper_limit;// upper_limit为数据上限 int sum;// sum为求和的结果 第10章合理使用数据类型 在进一步讨论更深的主题之前，我们需要先停一停，快速地回顾一下可移植问题。Linux1.2版本和2.0版本之间的不同就在于额外的多平台能力；结果是，大多数源代码级的移植问题已经被排除了。这意味着一个规范的Linux驱动程序也应该是多平台的。 但是，与内核代码相关的一个核心问题是，能够同时存取各种长度已知的数据项(例如,文件系统数据类型或者设备卡上的寄存器)和利用不同处理器的能力(32位和64位的体系结构,也有可能是16位的)。 当把x86的代码移植到新的体系结构上时，核心开发者遇到的好几个问题都和不正确的数据类型相关。坚持强数据类型以及编译时使用-Wall-Wstrict-prototypes选项能够防止大部分的臭虫。 内核使用的数据类型划分为三种主要类型：象int这样的标准C语言类型，象u32这样的确定数据大小的类型和象pid_t这样的接口特定类型。我们将看一下这三种类型在何时使用和如何使用。本章的最后一节将讨论把驱动器代码从x86移植到其它平台上可能碰到的其它一些典型问题。 如果你遵循我提供的这些准则，你的驱动程序甚至可能在那些你未能进行测试的平台上编译并运行。 使用标准C类型 大部分程序员习惯于自由的使用诸如int和long这样的标准类型，而编写设备驱动程序就必须细心地避免类型冲突和潜在的臭虫。 问题是，当你需要“2个字节填充单位(filler)”或“表示4个字节字符串的某个东西”时，你不能使用标准类型，因为通常的C数据类型在不同的体系结构上所占空间大小并不相同。例如，长整数和指针类型在Alpha上和x86上所占空间大小就不一样，下面的屏幕快照表明了这一点： morgana%./datasize system/machine:Linux i486 sizeof(char)=1 sizeof(short)=2 sizeof(int)=4 sizeof(long)=4 sizeof(longlong)=8 sizeof(pointer)=4 第１章绪论 1．简述下列概念：数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型。2．试举一个数据结构的例子，叙述其逻辑结构和存储结构两方面的含义和相互关系。 3．简述逻辑结构的四种基本关系并画出它们的关系图。 4．存储结构由哪两种基本的存储方法实现？ 5．选择题 （1）在数据结构中，从逻辑上可以把数据结构分成（）。 A．动态结构和静态结构B．紧凑结构和非紧凑结构 C．线性结构和非线性结构D．内部结构和外部结构 （2）与数据元素本身的形式、内容、相对位置、个数无关的是数据的（） A．存储结构B．存储实现C．逻辑结构D．运算实现 （3）通常要求同一逻辑结构中的所有数据元素具有相同的特性，这意味着（）。 A．数据具有同一特点 B．不仅数据元素所包含的数据项的个数要相同，而且对应数据项的类型要一致 C．每个数据元素都一样 D．数据元素所包含的数据项的个数要相等 （4）以下说法正确的是（）。 A．数据元素是数据的最小单位 B．数据项是数据的基本单位 C．数据结构是带有结构的各数据项的集合 D．一些表面上很不相同的数据可以有相同的逻辑结构 （5）以下与数据的存储结构无关的术语是（）。 A．顺序队列 B. 链表 C. 有序表 D. 链栈 （6）以下数据结构中，（）是非线性数据结构 A．树B．字符串C．队D．栈 6．试分析下面各程序段的时间复杂度。 （1）x=90; y=100; while(y>0) if(x>100) {x=x-10;y--;} else x++; （2）for (i=0; i 补充练习第八章构造数据类型 第八章构造数据类型 一、单项选择题： 1．设有以下语句： struct st{int n; struct st *next;}; static struct st a[3]={5,&a[1],7,&a[2],9,?\0?},*p; p=&a[0]; 则表达式的值是6。 A. p++ ->n B. p->n++ C. (*p).n++ D. ++p->n 2．若有下面的说明和定义，则sizeof(struct aa)的值是。 struct aa{int r1; double r2; float r3;} mya; A. 8 B. 10 C. 12 D. 14 3. 若程序中有下面的说明和定义： struct abc{int x; char y;} struct abc s1,s2; 则会发生的情况是。 A. 编译出错 B. 程序将顺利编译、连接、执行 C. 能顺利通过编译、连接，但不能执行 D. 能顺利通过编译，但连接出错 4．选择出k的正确值。 enum {a,b=5,c,d=4,e} k; k=e; A．3 B. 4 C. 5 D. 6 5．选择出不正确的函数定义：。 A．struct tree func(s) B. int *func(s) struct tree s[]; char *s[]; { { ... ... } } C. struct tree *func(s) D. int *func(s) char **s; char *s[10][]; { { ... ... } } 6．若有以下的说明，则在scanf函数调用语句中对结构体变量成员的不正确引用方式为。 struct pupil { char name[20]; int age; int sex; } pup[5], *p; p=&pup[0]; A．scanf(“%s”, pup[0].name); B. scanf(“%d”, &pup[0].age); C. scanf(“%d”, &(p->sex)); D. scanf(“%d”, &p->age); 7. 设有100个学生的考试成绩数据表如下形式： 在下面结构体数组的定义中，不正确的是： A．struct student B. struct stud [100] { { int no; int no; char name [10]; char name [10]; float score; float score; }; }; struct student stud[100]; C. struct student D. struct { { int no; int no; char name [10]; char name [10]; float score; float score; } stud[100]; ]stud[100]; 模块三变量声明、关键字和类型 模块三变量声明、关键字和类型 (1) 1. 基本语法元素 (2) 1.1. 注释 (2) 1.2. 分号 (2) 1.3. 语句块(block) (3) 1.4. 空白 (4) 2. 标识符 (4) 3. Java关键字 (5) 4. 基本Java数据类型 (5) 4.1. 逻辑型──boolean (6) 4.2. 字符型──char (6) 4.3. 文本类──String (7) 4.4. 整数型──byte, short, int, long (7) 4.5. 浮点数──float和double (8) 5. 变量、声明和赋值 (8) 6. 引用（Reference）类型 (9) 6.1. 创建一个新类型 (9) 6.2. 创建并初始化一个对象 (10) 6.3. 存储器分配和布局 (10) 6.4. 引用类型的赋值 (11) 6.5. 值传递 (12) 6.6. this引用 (14) 7. Java编码约定 (15) 8. 练习：使用对象 (16) 8.1. 创建一个类和相应的对象 (16) 8.2. 检验引用赋值 (16) 9. 检查你的进度 (17) 本模块阐述了在Java技术中使用的基本元素，包括变量、关键字、原始类型和类类型。 完成本模块的学习后，你应该能够： -区分有效和无效标识符 -识别Java技术关键字 -列出八个原始类型 -为数字类型和文本类型定义文字值 -解释术语class、object、member variable和reference variable -为一个简单的包含原始成员变量的类创建一个类定义 -声明类类型变量 -使用new构造一个对象 -描述缺省初始化 -使用点符号访问一个对象的成员变量 -描述一个引用变量的意义 -描述分配类类型变量的结果 3.1 基本语法元素 3.1.1 注释 注释是程序员用来标记、说明程序的。编译器会忽略注释中的内容，注释中的内容不会对程序的运行产生任何影响。Java语言允许三种风格的注释： // 单行注释 /* 多行注释 */ /** 文档注释 */ 3.1.2 分号 在Java编程语言中，语句是一行由分号(;)终止的代码。 例如 totals=a+b+c+ 6.2 用户自定义数据类型 6.2.1 创建用户自定义数据类型 可以使用T-SQL语句或企业管理器来完成用户自定义数据类型的创建。 1. 使用T-SQL语句 可以使用系统存储过程sp_addtype来创建用户自定义数据类型。语法是：sp_addtype type_name[,system_type] {'NULL'|'NOT NULL'|'NONULL'}-默认为'NULL' 其中： type_name为用户定义数据类型名，这个名称在数据库中必须是惟一的。 system_type 为用户定义的数据类型所基于的系统数据类型，可以包括数据的长度、精度等。当系统数据类型中包括标点符号(例如括号、逗号)时，应用引号括起来。 例如，创建一个“号码”数据类型可使用如下代码： USE 学生图书借阅管理 EXEC sp_addtype 号码,'varchar(8)','NULL' 在查询分析器中执行上述语句，结果窗口显示如下信息： (所影响的行数为1行) 类型已添加。 2. 使用企业管理器 使用企业管理器创建用户自定义数据类型的操作步骤如下： (1)在企业管理器中展开要创建用户自定义数据类型的数据库，用鼠标右键单击“用户定义的数据类型”目录，在弹出的快捷菜单中选择“新建用户定义数据类型”命令，如图6-14所示。 图6-14 新建用户自定义数据类型 (2)打开的用户自定义数据类型属性对话框如图6-15所示。在图6-15所示对话框的名 称文本框中输入用户自定义数据类型的名称，如“号码”。 图6-15 用户自定义数据类型属性对话框 图6-16 创建用户自定义数据类型“号码” (3)在图6-15所示对话框的“数据类型”下拉列表框中，选择该用户自定义数据类型所基于的系统数据类型，如varchar。 (4)如果选择的基类型是可以设定长度的(如varchar、char等)，则还需要在长度文本框中设定数据类型的长度。 (5)如果允许空值，则选中“允许NULL值”复选框。 (6)如果希望该数据类型与规则或默认值捆绑，则分别在“规则”和“默认值”下拉列表框中选择要绑定的规则和默认值，否则选择“无”，如图6-16所示。规则和默认值将在 6.3节和6.4节中介绍。 (7)单击“确定”按钮，关闭对话框。 6.2.2 查看用户自定义数据类型 要查看用户自定义数据类型，可以使用sp_help 系统存储过程来查看用户自定义数据 第十章-CO10_作业类型主数据维护流程 1.流程说明 此流程描述对作业类型在SAP系统中之维护（创建、修改、删除、冻结），以利于成本进行分摊。 家具公司实际业务中，作业类型仅作为计算生产成本，不作其他任何用途。因此，作业类型只有与生产部门之工作中心相关。另外，哪一类成本中心之费用及该费用通过作业类型分摊至哪个次级成本要素中去均须于创建作业类型时予以确定。 作业类型编码原则以及作业类型与次级成本要素之对应关系（参见附件一），由主数据专职维护人员统一定义、维护。 维护时，财务主数据维护专职人员须填写“作业类型主数据维护申请表”，作为SAP系统维护之依据。 注意事项： 通常，作业类型于SAP上线后即可交付使用，一般不需要创建、修改、删除或冻结。 因系统的高度集成，故创建作业类型前，必须与生产部门（PP模组）达成共识后方可进行，否则将引起前端部门作业困扰，冻结时亦然（若仅在CO模组已创建作业类型但不能与PP模组集成，则该作业类型是无用的）。 修改作业类型时，亦应事先与生产部门取得共识后方可进行。 2.流程图 3.系统操作 3.1.操作范例 例1：因公司内部核算需要，生技部门于2000/12/01起实行独立核算，各生产车间凡涉及之维 修费用均透过生技部门进行，生技部门按实际维修工时（维修内部价格按公司制定标准执行）结 算各生产车间费用。为此，财务部门决定创建一个作业类型——维修工时（代码：AMAINT）,以 满足依维修工时核算所需。 例2：上述作业类型创建后，发现中文名称定义不够恰当，变更为生技维修工时。 例3：生技部门试运行后，未能继续推行下去，故将作业类型冻结。 例4：将作业类型——维修工时（代码：AMAINT）删除 3.2.系统菜单及交易代码 案例1:会计→控制→成本中心会计→主数据→作业类型→单个处理→创建 交易代码：KL01 案例2:会计→控制→成本中心会计→主数据→作业类型→单个处理→更改 交易代码：KL02 从编译原理上来说，声明是仅仅告诉编译器，有个某类型的变量会被使用，但是编译器并不会为它分配任何内存。而定义就是分配了内存。 对于下面的两句代码： void Func() { int a; int b=1; a=0; } 对于第一行代码，编译器不会做任何事，它不会为它在栈中分配一点东西，直到第三句， a=0;时，编译器才会将其压入栈中。而对于int b=0;这一句，编译器就会生成一条指令，为它赋值。如果反汇编，看到的代码可能是这样的： push 1; push 0; 当然，并不一定编译器就会样做，也有可能在声明int a时，编译器就会把一个废值入栈，到第三条再为其赋值，这要看编译器的具体取舍，所以，声明不一定不是定义，而定义一定是定义。 但是，下面的声明，一定仅仅是声明： extern int a; 这表时，有一个int变量a，它一定是在另外其他地方定义的，所以编译器此时一定不会做什么分配内存的事，因为它就是声明，仅仅表明下面的代码引用了一个符号，而这个符号是int类型的a而已。 变量的声明，其实就是一个空的东西，在C中就相当与一个空的指针，它什么也没有指向，没有任何实际的意义，例如int a。 而变量的定义，就不一样了，它是在内存中指定了一定的空间，一旦定义一个变量，系统自动给它分配一定的内存空间。它是有一定的实际意义的。例如int a=10。 两者区别： 声明不为变量分配空间，而定义为变量分配空间 因此同一个变量的声明可以出现多次，而只能定义一次 中函数的声明是可以重复的，但是变量却不可以。对于变量的声明都会分配内存空间，只是这部分内存空间里存放的是随机值，直到被定义之后将赋予相应的值。 变量的声明和定义之间的区别和联系 前者是“定义性声明（defining declaration）”或者称为“定义（definition）”，而后者是“引用性声明（referncing declaration）”，从广义的角度来讲声明中包含着定义，即定义是声明的一个特例，所以并非所有的声明都是定义，例如：int a 它既是声明，同时又是定义。然而对于 extern a 来讲它只是声明不是定义。一般的情况下我们常常这样叙述，把建立空间的声明称之为“定义”，而把不需要建立存储空间的声明称之为“声明”。很明显我们在这里指的声明是范围比较窄的，即狭义上的声明，也就是说非定义性质的声明，例如：在主函数中： int main() { extern int A; //这是个声明而不是定义，声明A是一个已经定义了的外部变量 //注意：声明外部变量时可以把变量类型去掉如：extern A; dosth(); //执行函数 } int A; //是定义，定义了A为整型的外部变量 外部变量的“定义”与外部变量的“声明”是不相同的,外部变量的定义只能有一次，它的位置是在所有函数之外，而同一个文件中的外部变量声明可以是多次的，它可以在函数之内(哪个函数要用就在那个函数中声明)也可以在函数之外(在外部变量的定义点之前)。系统会根据外部变量的定义(而不是根据外部变量的声明)分配存储空间的。对于外部变量来讲，初始化只能是在“定义”中进行,而不是在“声明”中。所谓的“声明”，其作用，是声明该变量是一个已在后面定义过的外部变量，仅仅是为了“提前”引用该变量而作的“声明”而已。extern 只作声明，不作任何定义。 （我们声明的最终目的是为了提前使用，即在定义之前使用，如果不需要提前使用就没有单独声明的必要，变量是如此，函数也是如此，所以声明不会分配存储空间，只有定义时才会分配存储空间。） C语言中变量的声明和定义的关系 在英文里有两个词涉及这个问题：declare 和 define，在中文中这两个词都可以翻成“定义”，但在C语言中他们有不同的意义；让我们称declare=声明，define=定义。 “声明(declare)”是用于定义一个变量的类型；“定义(define)”是用于定义一个变量所占用的存储；显然，一个变量的类型可以定义多次，只要他们不互相矛盾即可；而一个变量的存储只能定义一次，否则程序如何用一个变量名访问多于一个的存储空间呢？ 每次引用一个变量时，引用变量的语句行之前必须出现该变量的声明，该声明可以是直接出现在这个语句行所在的源文件中，或出现在一个头文件中，该源文件用include包含这个头文件。 一个项目中可以有多个源文件，但在所有的源文件中只允许出现一次对某个变量的定义。 这里借用“新手园地”中小罗纳耳朵的一个问题作为例子： 我用Keil写程序时，子程序里需要用到定义一个数组 array[]={0x01，0x02} 放在main函数里定义会提示array未定义！ 但是如果放在头文件config.h里面定义为： extern code unsigned CHAR array[]={0x01，0x02}; 结果编译时出现 MULTIPLE PUBLIC DEFINITIONS定义。但是我的头文件里面已经用预处理 命令了 #ifndef __CONFIG_H__ #define __CONFIG_H__ 头文件的内容 #endif 为什么还会出现这种重复定义的错误？ 他的错误是，下面这行是定义array的存储，而他又把这行放到了头文件config.h中，等于是在多个源文件中重复地定义array的存储： extern code unsigned CHAR array[]={0x01，0x02}; 正确的做法是在头文件中用这样的声明语句(必须加extern，否则变成定义存储了)：extern code unsigned CHAR array[]; // 声明array是一个外部变量 然后在某个源文件中加入这样的语句(此处不必加extern)： code unsigned CHAR array[] = {0x01, 0x02}; // 定义array的存储 AB PLC编程软件RSLOGIX5000入门7——UDT用户自定义数据类型 在本章中，我们将介绍如何通过用户自定义数据类型和数据范围划定来规划标签数据库。这里将学到 § 了解使用 UDT 的优势 § 学习如何优化 UDT 规划 § 使用数据范围划定帮助简化并加快开发工作 我们现在将重点关注 Logix 控制器中的数据规划。 打开现有控制器文件 1. 在计算机桌面上，双击 Lab Files 文件夹。 2. 双击名为 Conveyor_Program_S 3.ACD 的现有项目。 这样将在 RSLogix 5000 中启动该项目。 为传送带创建用户自定义数据类型 您已重新组织了程序规划以更好地利用 Logix，现在已准备好开始对数据规划进行重新组织。可注意到，工程师规划数据的方式仍像使用带有整数、实数和定时器数据表的传统 PLC 一样。问题是，当与设备关联的数据分布到控制器内存中的各处时便很难进行跟踪。您已再次决定充分利用 Logix，使用用户自定义数据类型。 用户自定义数据类型 用户自定义数据类型也称为 UDT 或结构，借此按逻辑方式对数据进行组织或分组，以便所有与设备关联的数据都可组合在一起。 例如，每个传送带都有 8 个整数值、3 个实数值、2 个定时器和 11 个与其关联的布尔值。在传统PLC 中，可能需要 4 个不同的数据表。然后，当您具有多条传送带时，您可能需要详细地将传送带映射到各个数据表中。这样就会变得很难管理。 通过 UDT 能够实现的是将不同的数据类型（整数、实数、定时器、布尔等）组合到一起，共同作为用户自定义数据类型。然后便可创建该 UDT 类型的数组。这可使得编程工作、代码的记录和数据的跟踪都更加轻松。 1. 在控制器项目管理器中，双击"控制器标签"(Controller Tags)。 变量定义与声明的区别我们在程序设计中，时时刻刻都用到变量的定义和变量的声明，可有些时候我们对这个概念不是很清楚，知道它是怎么用，但却不知是怎么一会事，下面我就简单的把他们的区别介绍如下: 变量的声明有两种情况: (1 一种是需要建立存储空间的(定义、声明。例如：int a在声明的时候就已经建立了存储空间。 (2 另一种是不需要建立存储空间的(声明。例如：extern int a其中变量a是在别的文件中定义的。前者是"定义性声明(defining declaration"或者称为"定义(definition",而后者是"引用性声明(referncing declaration"。从广义的角度来讲声明中包含着定义，但是并非所有的声明都是定义，例如:int a它既是声明，同时又是定义。然而对于extern a来讲它只是声明不是定义。一般的情况下我们常常这样叙述，把建立空间的声明称之为"定义"，而把不需要建立存储空间称之为"声明"。很明显我们在这里指的声明是范围比较窄的，也就是说非定义性质的声明。例如：在主函数中 int main( { extern int A; //这是个声明而不是定义，声明A是一个已经定义了的外部变量 //注意：声明外部变量时可以把变量类型去掉如：extern A; dosth(; //执行函数 } int A; //是定义，定义了A为整型的外部变量(全局变量外部变量(全局变量的"定义"与外部变量的"声明"是不相同的,外部变量的定义只能有一次，它的位置是在所有函数之外，而同一个文件中的外部变量声明可以是多次的，它可以在函数之内(哪个函数要用就在那个函数中声明也可以在函数之外(在外部变量的定义点之前。系统会根据外部变量的定义(而不是根据外部变量的声明分配存储空间的。对于外部变量来讲，初始化只能是在"定义"中进行,而不是在"声明"中。所谓的"声明"，其作用，是声明该变量是一个已在后面定义过的外部变量，仅仅是在为了"提前"引用该变量而作的"声明"而已。extern只作声明，不作定义。用static来声明一个变量的作用有二： (1 对于局部变量用static声明，则是为该变量分配的空间在整个程序的执行期内都始终存在 (2 外部变量用static来声明，则该变量的作用只限于本文件模块 一，单选题 1. 已知枚举类型定义语句为： enum Token { NAME, NUMBER, PLUS=5, MINUS, PRINT=10 }; 则下列叙述中错误的是( )。 A 枚举常量NAME的值为1 B 枚举常量NUMBER的值为1 C 枚举常量MINUS的值为6 D 枚举常量PRINT的值为10 参考答案 A 2. 当定义一个结构体变量时，系统分配给它的内存大小的理论值是__________。 A 各成员所需内存的总和 B 结构体中的第一个成员所需内存 C 成员中所需内存最大者的存储空间 D 结构体中的最后一个成员所需存储容量 参考答案 A 3. 以下对枚举类型名的定义中正确的是（）。 A enum a={“one”, “two”, “three”}; B enum a {“one”, “two”, “three”}; C enum a={one, two, three}; D enum a {one=9,two=-1,three}; 参考答案 D 4. 下面程序的正确的输出是（）。 #include 5. 设有以下定义： enum t1 {a1,a2=7,a3,a4=15} time; 则枚举常量a1和a3的值分别是 A 1和2 B 6和3 C 1和8 D 0和8 参考答案 D 6. 设有类型说明： enum color{red, yellow=3, white, black}; 则执行语句cout<自定义数据类型习题及答案(C语言)
C语言中变量和函数的声明与定义
若变量均已正确定义并赋值
用户定义数据类型与自定义函数
C语言自定义数据类型
变量的定义与声明
第10章 合理使用数据类型
数据结构1-10章习题
补充练习第八章构造数据类型
变量声明、关键字和类型
sql自定义数据类型
第十章-CO10-作业类型主数据维护流程.
C语言的变量声明与定义的区别
变量的声明和定义之间的区别和联系
C语言中变量的声明和定义的关系
AB PLC编程软件RSLOGIX5000入门7——UDT用户自定义数据类型
变量定义与声明的区别(精)
C++(练习)第5章,自定义数据类型
相关主题
文本预览