 |
struct 和 class 的区别
|
|
| |
| 答案：struct 的成员默认是公有的，而类的成员默认是私有的。struct 和 class 在其他方面是功能相当的。从感情上讲，大多数的开发者感到类和结构有很大的差别。感觉上结构仅仅象一堆缺乏封装和功能的开放的内存位，而类就象活的并且可靠的社会成员，它有智能服务，有牢固的封装屏障和一个良好定义的接口。既然大多数人都这么认为，那么只有在你的类有很少的方法并且有公有数据（这种事情在良好设计的系统中是存在的!）时，你也许应该使用 struct 关键字，否则，你应该使用 class 关键字。本文转载自IT网it求职笔试真题库网。
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读767次，回复0次 |
|
|
|
当一个类A 中没有生命任何成员变量与成员函数,这时sizeof(A)的值是多少
|
|
| |
| 当一个类A 中没有生命任何成员变量与成员函数,这时sizeof(A)的值是多少，如果不是零，请解释一下编译器为什么没有让它为零。 答案：肯定不是零。举个反例，如果是零的话，声明一个class A[10]对象数组，而每一个对象占用的空间是零，这时就没办法区分A[0],A[1]…了。本文转载自IT网it求职笔试真题库网。
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读724次，回复0次 |
|
|
|
关联、聚合(Aggregation)以及组合(Composition)的区别？
|
|
| |
| 涉及到UML中的一些概念：关联是表示两个类的一般性联系，比如“学生”和“老师”就是一种关联关系；聚合表示has-a的关系，是一种相对松散的关系，聚合类不需要对被聚合类负责，如下图所示，用空的菱形表示聚合关系： 从实现的角度讲，聚合可以表示为:class A {...} class B { A* a; .....}而组合表示contains-a的关系，关联性强于聚合：组合类与被组合类有相同的生命周期，组合类要对被组合类负责，采用实心的菱形表示组合关系： 实现的形式是:class A{...} class B{ A a; ...}本文转载自IT网it求职笔试真题库网。
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读1213次，回复0次 |
|
|
|
stl学习笔记1（入门速览与迭代器）
|
|
| |
| 一入门: stl速览 STL的一个重要特点是数据结构和算法的分离。尽管这是个简单的概念，但这种分离确实使得STL变得非常通用。例如，由于STL的sort()函数是完全通用的，你可以用它来操作几乎任何数据集合，包括链表，容器和数组。1.1 头文件和名字空间为了避免和其他头文件冲突， STL的头文件不再使用常规的.h扩展。表 1. STL头文件和容器类#includeContainer Class<deque>deque<list>list<map>map, multimap<queue>queue, priority_queue<set>set, multiset<stack>stack<vector>vector, vector<bool>为了使用STL，可以将下面的指示符插入到你的源代码文件中，典型地是在所有的#include指示符的后面：using namespace std;1.2 六大组件1） 迭代器提供了访问容器中对象的方法。例如，可以使用一对迭代器指定list或vector中的一定范围的对象。迭代器就如同一个指针。事实上，C++的指针也是一种迭代器。但是，迭代器也可以是那些定义了operator*()以及其他类似于指针的操作符地方法的类对象。2） 容器是一种数据结构，如list，vector，和deques ，以模板类的方法提供。为了访问容器中的数据，可以使用由 ...
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读1261次，回复0次 |
|
|
|
using namespace std
|
|
| |
| 所谓namespace，是指标识符的各种可见范围。C＋＋标准程序库中的所有标识符都被定义于一个名为std的namespace中。由于namespace的概念，使用C＋＋标准程序库的任何标识符时，可以有三种选择：1、直接指定标识符。例如std::ostream而不是ostream。完整语句如下：std::cout << std::hex << 3.4 << std::endl;2、使用using关键字。using std::cout;using std::endl;以上程序可以写成cout << std::hex << 3.4 << endl;3、最方便的就是使用using namespace std，这样命名空间std内定义的所有标识符都有效（曝光）。就好像它们被声明为全局变量一样。那么以上语句可以如下写:cout << hex << 3.4 << endl;本文转载自IT网it求职笔试真题库网。
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读1038次，回复0次 |
|
|
|
一道c++面试题 －－－－－常量的分配位置
|
|
| |
| char str1[] = "abc"; // char str2[] = "abc"; const char str3[] = "abc"; const char str4[] = "abc"; const char* str5 = "abc"; const char* str6 = "abc"; cout << boolalpha << ( str1==str2 ) << endl; //false cout << boolalpha << ( str3==str4 ) << endl; //false cout << boolalpha << ( str5==str6 ) << endl; //falseOut: false false true本文转载自IT网it求职笔试真题库网。
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读1046次，回复0次 |
|
|
|
友元小结
|
|
| |
| 有一种机制可以摆脱public/protected/private等访问权限的限制 -- 友元友元冠以关键字friend, 只能出现在类的声明中.一个友元可以是一个类, 一个类的成员函数, 或一个名字空间函数.本文转载自IT网it求职笔试真题库网。
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读806次，回复0次 |
|
|
|
再一次吃惊----数组的数组与多维数组的区别
|
|
| |
| 看见这个题目，也许有些人就会嘀咕了：难道两者不是一样的吗？C语言的多维数组不就是数组的数组吗？不！两者是有区别的，而且还不小呢。首先看看两者的共同点：1。内存映象一样。2。数组引用方式一样，都是“数组名[下标][下标]........”。3。数组名都是数组的首地址，都是一个符号地址常量、一个右值。 由于两者的共同点主要反映在外部表现形式上，因此，从外部看来，数组的数组跟多维数组似乎是一样的，这造成了C程序员对两者的区别长期以来模糊不清。但实际上，c语言限于本身的语言特性，实现的并非真正的多维数组，而是数组的数组。 数组的数组与多维数组的主要区别，就在于数组的数组各维之间的内在关系是一种鲜明的层级关系。上一维把下一维看作下一级数组，也就是数组嵌套。数组引用时需要层层解析，直到最后一维。举个例，对于数组：int a[7][8][9]；如果要访问元素a[4][5][6]，首先就要计算第一维元素4的地址，也就是a+4，由于是数组的数组，元素4的值代表了一个数组，因此元素4的值就是它所代表的那个数组的首地址，我们用一个符号address1代表它，也就是address1=*(a+4)，接着计算第二维，显然元素5的地址是address1+5，其值也是一个数组的首地址，用address2表示它，就是address2=*(address1+5)，最后一维，由于已经到达了 ...
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读963次，回复0次 |
|
|
|
数组的解剖学
|
|
| |
| 这一章我们来讨论一下数组的内涵，对数组的内部构造进行一次解剖，看看里面究竟隐藏了什么秘密。 有了前面两章对数组名和C语言数组本质的澄清，再来理解这一章的内容，就容易多了。 在下面的叙述中，笔者会用到一个运算符sizeof，由于在不同的编译器和编译模式下，对一个地址进行sizeof运算的结果有可能是不同的，为了方便讨论，我都假设地址长度为4个字节。 多数教材在讲述数组的时候，都是把重点放在外部表现形式上，很少涉及数组的内部，只告诉你如何做，却忽视了为什么要这样做。在解释的过程中，还会列出各种各样的表达式，例如：a、a+1、a[0]、a[0][0]、&a[0]、&a[0][0]、*(a+1)等等，让人眼花缭乱。但实际上真正能够用来描述数组内部构造的表达式只有其中的几个。 上一章讲到，C语言的数组实现并非真正的多维数组，而是数组嵌套，访问某个元素的时候，需要逐层向下解析。仍然以上一章的例子数组int a[7][8][9]来说，第一维元素0的值a[0]是a[0]所代表的那个数组的首地址，这个表达式在C语言的数组里面具有特殊的意义，之所以特殊，不仅仅在于它所代表的东西与一般的地址不同，而且类型也并非一般的地址类型，它的类型叫做数组类型，数组类型这个名称在绝大多数教材中是从来没有出现过的，在C89标准中，也仅仅出现在介绍数组定义的那一段。具有数组类型的 ...
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读902次，回复0次 |
|
|
|
[ ]运算符的本质
|
|
| |
| 数组是存在于人们头脑中的一个逻辑概念，而编译器其实并不知道有数组这个东西，它所知道的，只是[]运算符，当遇到[]运算符的时候，编译器只是简单地把它转换为类似*(*(a+i)+j)这样的等价表达式，之所以是这种表达式，如前几章所述，是因为C语言的数组实现本质上是数组的嵌套。 由于这种等价关系的存在，会产生一些古零精怪的表达式，例如：10[a]这个表达式初看上去让人摸不着头脑，它是什么呢？如上所述，编译器会把它转换为*(10+a)，把a和10调换一下，就是*(a+10)了，这个就是a[10]。[]运算符之前还可以是一个表达式，例如：(10+20)[a]。严格来讲，以上两个表达式是非法的，因为C89对于数组的引用（注意不是数组定义）规定：带下标的数组引用后缀表达式由一个后缀表达式后跟一个括在方括号中的表达式组成。方括号前的后缀表达式的类型必须为“指向T类型的指针”，其中T为某种类型；方括号中表达式的类型必须为整型。这个规定说明，进行数组引用的时候，[]运算符的左边并非必须为数组名，而可以是一个表达式，但这个表达式的类型必须为“指向某类型的指针”。显然10跟(10+20)连地址都不是，因此实际上他们是非法的，编译器在这里并没有严格遵守标准的规定。但如果是：int a[10], *p = a;(p+1)[2]这样就是合法的，因为p+1的结果仍然是一个指针。要注意的是，虽然后缀 ...
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读860次，回复0次 |
|
|
|
另类”数组
|
|
| |
| 动态数组与字符串常量可算是两种“另类”数组。 VLA可变长数组并不为C89所支持，C99才开始支持VLA。但如果想在只支持C89的编译环境中使用VLA的话，怎么办呢？我们可以用动态数组来“模拟”，动态数组在矩阵的运算中很常见，常用来向函数传递一个大小可变的矩阵。动态数组的原理，是利用一块或多块动态分配的内存存储各维的首地址，这样就可以p[j]的形式访问数组的数据了。但是，动态数组并非真正的数组，它只是对数组的一种模拟。由于具有数组类型的数组名是系统行为，在用户这一级没法做到，因此只能以指针的形式存放首地址，sizeof(p)和sizeof(p)结果都是4字节。虽然动态数组是依靠动态分配内存来建立的，但动态的意义并非来自这里，而是指大小可变。笔者觉得用“动态数组”这个名称来命名非常适合，既不失大小可变的特征，又可以跟VLA可变长数组区分开来。 下面是建立动态数组的示例：#include <stdio.h>#include <stdlib.h>void computedata(int *, int, int);int main(void){ int iData[100], x, y; do { printf("The product obtained by multiplying x a ...
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读957次，回复0次 |
|
|
|
指向数组的指针
|
|
| |
| 讲到第五章了，数组两个字还离不开我们的左右，数组的内容也真多，另一方面也因为数组与指针的关系的确非常密切。 通常，对于int a[8][9]这个二维数组，我们可以这样定义一个指向它的指针：int (*p)[9];这个声明的形式跟人们所熟悉的int *p的形式大相庭径，初学者通常会感到迷惑，不理解的地方大致有四个：1。为什么会以这种形式声明？2。(*p)应该如何理解？3。为什么必须把第二维显式地声明？4。为什么忽略第一维？下面我们就一起逐个讨论这四个问题：1。这种形式是C标准的声明语法规定的，由于本章不是对标准的解释，只是对标准的应用，因此笔者尽量以简洁的方式解释这个声明，详细的讨论将在第七章进行。C标准的声明包含了两部分：声明：声明说明符 初始化声明符表opt (opt的意思是可选)在声明说明符里面有一项类型说明符，int就是这种类型说明符。而初始化声明符表里面的其中一种形式，就是：直接声明符 [常量表达式opt](*p)[9]就是这种直接声明符加[]的形式。2。p左边的*在这里不是取值运算符，而是一个声明符，它指出p是一个指针。而()括号是不能去掉的，如果去掉了，由于[]运算符优先级比*高，p就会先跟[]结合，这样p就变成了一个指针数组，而不是指向数组的指针。题外话：*p还有一种用法，就是当*是取值运算符的时候，*p是一个左值，表示一个变量，为什么* ...
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读1048次，回复0次 |
|
|
|
C语言声明详解
|
|
| |
| 人们常说，C语言的声明太复杂了，的确，这也是C语言饱受批评的地方之一。不过，笔者认为，真正要受到批评的不是语言本身，而是那些传播者。传播者们通常都有一个共识：讲述要由浅入深。作为原则，笔者并非要反对它，毕竟笔者对C语言的学习，也经历了相同的过程。但是，由浅入深并不意味着一切从简，以偏盖全。计算机语言不同于数学理论（虽然它的确根植于数学，与数学密不可分），数学理论是一种循序渐进的过程，后面的理论以前面的理论为基础。但C语言归根说底，就是一堆语言规则而已，应该让学习者一开始就全面且详细地了解它，而不是象现在某些教材所做的那样，只说一部分，不说另一部分，以为这就是由浅入深了，实际上这是以偏盖全。 语言如此，声明作为C语言的一部分更是如此。我们最常见到的对声明的描述是这样的：存储类别 类型限定词 类型 标识符这种说明会给人们一种暗示：C语言的声明是静止的、死板的，什么声明都能够以这个为基础，往上一套就OK了。事实真的如此吗？说句心里话，笔者也祈祷事实真的如此，这样世界就简单多了、清静多了。但别忘了，这个世界总是让人事与愿违的。实际上，C的声明的组织形式是以嵌套为基础的，是用嵌套声明组织起来的，并非象上面所述那么死板，存储类说明符一定得放在限定词前面吗？类型说明符一定要紧贴标识符吗？不！C标准从来没有这样说过！下面来看一看C89对声明的形式是如何规定的：声明：声明说明符 ...
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读989次，回复0次 |
|
|
|
右左法则----复杂指针解析
|
|
| |
| 上一章费那么多唇舌讨论C语言的声明，其实目的都是为了这一章，期望读者通过对C语言声明形式的详细了解，树立声明嵌套的观念，因为C语言所有复杂的指针声明，都是由各种声明嵌套构成的。如何解读复杂指针声明呢？右左法则是一个既著名又常用的方法。不过，右左法则其实并不是C标准里面的内容，它是从C标准的声明规定中归纳出来的方法。C标准的声明规则，是用来解决如何创建声明的，而右左法则是用来解决如何辩识一个声明的，两者可以说是相反的。右左法则的英文原文是这样说的：The right-left rule: Start reading the declaration from the innermost parentheses, go right, and then go left. When you encounter parentheses, the direction should be reversed. Once everything in the parentheses has been parsed, jump out of it. Continue till the whole declaration has been parsed. 这段英文的翻译如下：右左法则：首先从最里面的圆括号看起，然后往右看，再往左看。每当遇到圆括号时，就应该掉转阅读方向。一旦解析完圆括号里面所有的东西，就跳出 ...
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读990次，回复0次 |
|
|
|
指针与const
|
|
| |
| const一词是英文constant的缩写，设立这个关键字的本意，是希望让它所修饰的对象成为一个常量。记得在国家间的外交中，有一个经常用到的术语：“从事与身份不符的活动”，这个const恰恰也正从事着这样的活动，呵呵。C语言可以有三种方法定义一个常量：#define、const和枚举，但只有枚举才是真正的常量，什么是真正的常量？真正的常量是没有存储空间的，是一个右值，这意味着通过任何合法的手段也不会被修改，但被const修饰的对象依然是一个左值，尽管这个对象被const限定，笔者仍然至少可以找到三种合法的手段去修改它，而#define所做的只不过是编译期替换而已，只有枚举常量才能真正做到这一点。const实在不应该被命名为const，这会让人们产生误解，它应该命名为readonly或类似的字眼，意即不能通过被const修饰的对象修改它所指向的对象或者它所代表的对象。但在C的世界里把const称为常量早已是普遍的现象，那我们就只好随大流咯，也称之为常量吧，只要知道它实际上不是真正的常量就行了。 第七章曾经讨论过const int *p;与int * const p的区别，这两个声明的中文名称常常搞得混乱不堪。第一个声明的const是声明说明符，它修饰p所指向的对象，但p仍然是可变的，这意味着p是一个指向常量的指针，简称常量指针。第二个声明的const是声明符的一部分，它 ...
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读1014次，回复0次 |
|
|
|
围绕p()与(*p)()的争论
|
|
| |
| 对于一个函数：void func(void);我们通常可以定义一个这样的函数指针指向它：void (*p)(void) = func;通过p调用func时，通常有两种写法：p();或者(*p)(); 围绕这两种写法，当初C89制定的时候曾经有过争论。(*p)();是一种旧式的规定，旧式规定圆括号左边必须具有“函数”类型，如果是指向函数的指针，那么必须加上*声明符。但C89不再把圆括号的左边限定为“函数”类型，而是一个后缀表达式。那么问题就来了，如果p的值是函数地址，那么*号就是声明符，但如果p指向的内容是函数地址，*号就得被看作运算符了。同一种形式会有两种解释，这是一个矛盾。不仅函数调用如此，指向数组的指针也存在这种矛盾。编译器为了处理这种情况得增加代码，效率自然就降低了。争论的最后结果是谁也不能把对方完全说服，于是就干脆两种都支持了。笔者认为应该抛弃旧式的规定，p();这种形式简洁明了，又符合函数的一般形式，何乐而不为？ 第八章练习的答案，同时给出用typedef的分解方法：int (*(*func)[5][6])[7][8];func是一个指向数组的指针，这类数组的元素是一个具有5X6个int元素的二维数组，而这个二维数组的元素又是一个二维数组。typedef int (*PARA)[7][8];typedef PARA (*func)[5][6];int (*( ...
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读1004次，回复0次 |
|
|
|
C++和C的不同点
|
|
| |
| C++和C的不同点1.C++比C多了一种注释方式:双斜杠注释一次可注释一行. 例: int i; i=0; // 这一行是注释,下一行将i加一. i++;2.在C++中,变量可以随时处定义,而在C中必须在程序和函数的开始处定义. 例: /*这里是C的例子*/ int i; for(i=0;i<10;i++); //如果是C++可以将i在用时再定义. for(int i=0;i<10;i++);3.在C中声明一个struct结构,那么在用的时候要加上struct关键字,在C++中不需要.*同样的,enum结构和union结构中也是如此. 例: /*在C语言里*/ struct st {int x,y;}; /*用时:*/ struct st myst; //在C++中可以这样 struct st {int x,y;}; //用时: st myst;4.在C++中使用了新的IO库:iostream.h在C中只有stdio.h. 例: #include <i ...
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读1143次，回复0次 |
|
|
|
i++,i--的前置,后置++i,--i的详细解释
|
|
| |
| 对i++,i--,++i,--i的易解,在此举一例子详解: main( ) { int x,y,z; x=y=2;z=3; y=x++-1;printf("%d\t%d\t",x,y); /*x=3,y=1,后置++,先把x赋值给y,再做运算,而x的值无论是前还是后置都加1*/ y=++x-1;printf("%d\t%d\t",x,y);/*x=4,y=3,前置++,先把x加1后赋值给y,然后做运算(此行x初值是上行的终值=3)*/ y=z--+1;printf("%d\t%d\t",z,y); /*z=2,y=4,同上理可知*/ y=--z+1;printf("%d\t%d\t",z,y); /*z=1,y=2,同理可证*/ getch(); } 希望能给初学者带来易处,你要多多发表和支持菜鸟的文章哟~~本文转载自IT网it求职笔试真题库网。
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读999次，回复0次 |
|
|
|
指针和函数的关系
|
|
| |
| 可以把一个指针声明成为一个指向函数的指针。 int fun1(char*,int); int (*pfun1)(char*,int); pfun1=fun1; .... .... int a=(*pfun1)("abcdefg",7);//通过函数指针调用函数。 可以把指针作为函数的形参。在函数调用语句中，可以用指针表达式来作为 实参。 例十三： int fun(char*); int a; char str[]="abcdefghijklmn"; a=fun(str); ... ... int fun(char*s) { int num=0; for(int i=0;i { num+=*s;s++; } return num; ) 这个例子中的函数fun统计一个字符串中各个字符的ASCII码值之和。前面说了，数组的名字也是一个指针。在函数调用中，当把str作为实参传递给形参s后，实际是把str的值传递给了s，s所指向的地址就和str所指向的地址一致，但是str和s各自占用各自的存储空间。在函数体内对s进行自加1运算，并不意味着同时对str进行了自加1运算。本文转载自IT网it求职笔试真题库网。
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读832次，回复0次 |
|
|
|
指针的算术运算
|
|
| |
| 指针可以加上或减去一个整数。指针的这种运算的意义和通常的数值的加减运算的意义是不一样的。例如： 例二： 1。 char a[20]; 2。 int *ptr=a; ... ... 3。 ptr++; 在上例中，指针ptr的类型是int*,它指向的类型是int，它被初始化为指向整 形变量a。接下来的第3句中，指针ptr被加了1，编译器是这样处理的：它把指针ptr的值加上了sizeof(int)，在32位程序中，是被加上了4。由于地址是用字节做单位的，故ptr所指向的地址由原来的变量a的地址向高地址方向增加了4个字节。 由于char类型的长度是一个字节，所以，原来ptr是指向数组a的第0号单元开始的四个字节，此时指向了数组a中从第4号单元开始的四个字节。 我们可以用一个指针和一个循环来遍历一个数组，看例子： 例三： int array[20]; int *ptr=array; ... //此处略去为整型数组赋值的代码。 ... for(i=0;i<20;i++) { (*ptr)++; ptr++； } 这个例子将整型数组中各个单元的值加1。由于每次循环都将指针ptr加1，所 以每次循环都能访问数组的下一个单元。 再看例子： 例四： 1。 char a[20]; 2。 int *ptr=a; ... ... 3。 ptr+=5; 在这个例子中，ptr被加上了5，编译器是这样处理的：将指 ...
|
|
| 作者:不祥 oases2008张贴于2005-01-01 00:00:00.0，共阅读1012次，回复0次 |
|
|
