string中c_str(),data(),copy(p,n)函数的用法总结
字体：[ ] 类型：转载 时间：
以下是对string中c_str(),data(),copy(p,n)函数的用法进行了详细的介绍，需要的朋友可以过来参考下
标准库的string类提供了3个成员函数来从一个string得到c类型的字符数组：c_str()、data()、copy(p,n)。
1. c_str()：生成一个const char*指针，指向以空字符终止的数组。
注：①这个数组的数据是临时的，当有一个改变这些数据的成员函数被调用后，其中的数据就会失效。因此要么现用先转换，要么把它的数据复制到用户自己可以管理的内存中。注意。看下例： 代码如下:const char* string s="1234"; c = s.c_str();& cout&&c&& //输出：1234 s="abcd"; cout&&c&& //输出：abcd 上面如果继续用c指针的话，导致的错误将是不可想象的。就如：1234变为abcd
其实上面的c = s.c_str(); 不是一个好习惯。既然c指针指向的内容容易失效，我们就应该按照上面的方法，那怎么把数据复制出来呢？这就要用到strcpy等函数（推荐）。 代码如下://const char* //① //char*&&&&&& //② //char c[20];& char* c=new char[20]; string s="1234"; //c = s.c_str();& strcpy(c,s.c_str()); cout&&c&& //输出：1234 s="abcd"; cout&&c&& //输出：1234注意：不能再像上面一样①所示了，const还怎么向里面写入值啊；也不能②所示，使用了未初始化的局部变量“c”，运行会出错的 。
② c_str()返回一个客户程序可读不可改的指向字符数组的指针，不需要手动释放或删除这个指针。
2. data():与c_str()类似，但是返回的数组不以空字符终止。
3. copy(p,n,size_type _Off = 0)：从string类型对象中至多复制n个字符到字符指针p指向的空间中。默认从首字符开始，但是也可以指定，开始的位置（记住从0开始）。返回真正从对象中复制的字符。------用户要确保p指向的空间足够保存n个字符。 代码如下:// basic_string_copy.cpp // compile with: /EHsc /W3 #include &string& #include &iostream& int main( ) { &&& &&& string str1 ( "" ); &&& basic_string &char&::iterator str_I &&& char array1 [ 20 ] = { 0 }; &&& char array2 [ 10 ] = { 0 }; &&& basic_string &char&:: pointer array1Ptr = array1; &&& basic_string &char&:: value_type *array2Ptr = array2; &&& cout && "The original string str1 is: "; &&& for ( str_Iter = str1.begin( ); str_Iter != str1.end( ); str_Iter++ ) &&&&&&& cout && *str_I &&& cout && &&& basic_string &char&:: size_type nArray1; &&& // Note: string::copy is potentially unsafe, consider &&& // using string::_Copy_s instead. &&& nArray1 = str1.copy ( array1Ptr , 12 );& // C4996 &&& cout && "The number of copied characters in array1 is: "&&&&&&& && nArray1 && &&& cout && "The copied characters array1 is: " && array1Ptr && &&& basic_string &char&:: size_type nArray2; &&& // Note: string::copy is potentially unsafe, consider &&& // using string::_Copy_s instead. &&& nArray2 = str1.copy ( array2Ptr , 5 , 6& );& // C4996 &&& cout && "The number of copied characters in array2 is: "&&&&&&& && nArray2 && &&& cout && "The copied characters array2 is: " && array2Ptr && &&& ////注意一定要使array3有足够的空间 &&& //char array3[5]={0}; &&& //basic_string&char&::pointer array3Ptr=array3; &&& //basic_string&char&::size_type nArray3; &&& //nArray3 = str1.copy(array3,9); //错误！！！！ &&& //cout&&"The number of copied characters in array3 is: " &&& //& &&nArray3&& &&& //cout&&"The copied characters array3 is: "&&array3Ptr&& }上面最后注释掉的部分，虽然编译没有错误，但是运行时会产生错误：Stack around the variable 'array3' was corrupted.
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具我想问一下：当执行Hello的时候,它会自动的找到构造函数吗/就是执行p=str?-中国学网-中国IT综合门户网站-提供健康,养生,留学,移民,创业,汽车等信息
> 信息中心 >
我想问一下：当执行Hello的时候,它会自动的找到构造函数吗/就是执行p=str?
来源：互联网 发表时间： 9:19:22 责任编辑：李志喜字体：
为了帮助网友解决“我想问一下：当执行Hello的时候,它会自动的找到构造函数吗/就是执行p=str?”相关的问题，中国学网通过互联网对“我想问一下：当执行Hello的时候,它会自动的找到构造函数吗/就是执行p=str?”相关的解决方案进行了整理,用户详细问题包括:RT,我想知道:我想问一下：当执行Hello的时候,它会自动的找到构造函数吗/就是执行p=str?，具体解决方案如下：解决方案1：
是的，构造函数分为有参数的和无参数的书中调用的是有参构造。
解决方案2：
当然可以，重载了构造函数，可以通过参数列表区分不同函数
解决方案3：
是的，默认构造函数没有参数。
1个回答1个回答3个回答12个回答1个回答2个回答1个回答
相关文章：
最新添加资讯
24小时热门资讯
Copyright © 2004- All Rights Reserved. 中国学网 版权所有
京ICP备号-1 京公网安备02号求指针和数组名的区别 char *str 和 char str[]的不同之处？_内存_百科问答
求指针和数组名的区别 char *str 和 char str[]的不同之处？
提问者:鲁雪民
一个简单的字符串相关程序，运行时崩溃，罪魁祸首 char *str 和 char str[]的不同之处代码如下：#include &iostream& void deletechar(char *str,char ch){//从字符串str中删掉所有字符ch char *p=str,*q; while(*p) { if(*p!=ch){ p++; }else{ q=p; for(;*(p+1);++p){ *p = * (p+1); //Stop! }//for(;*(p+1);++p) *p='\0'; p=q; }//if-else }//while}//void deletechar(char *str,char ch) int main(){ char *str=&abccd&; char ch='c'; deletechar(str,ch); cout&&str&& return 0;}//int main()
上述代码编译链接后，运行时程序崩溃，崩溃？？！！仔细分析了这两个函数，没发现有什么不对。疯了，我也快蓝屏了，: ( 定一下，进入debug当运行到上面 //Stop!处出错 Unhandled exception in test.exe:0xC0000005:Access Violation停在汇编指令 mov byte ptr [edx],cl 处，说明执行该指令出错，(将寄存器值写内存时出错，也即将* (p+1)的值写到*p 时候出错，该指令的上一指令是 mov cl,byte ptr [eax+1] ，将* (p+1)写入寄存器) 用WinDbg进一步分析同样执行到上述那行代码后停止(Access violation)(在指令mov byte ptr [edx],cl )写内存错！！？？奇怪！看下内存中的内容： 63 64 00 ccd在偏移地址0046f02e处开始四个字节分别是63 63 64 00 就是字母ccd的ASCII值，就是主函数字符串&abccd&中内容没有问题啊？ 用windbg的命令查看下这块内存信息，如下!address edx
MEM_IMAGE Protect
PAGE_READONLY State
MEM_COMMIT Usage RegionUsageImage FullPath test.exe显示Protect
PAGE_READONLY，更奇怪了！？ 内存只读！*p = * (p+1); //p所指向的内存位置只读！ 把这个问题拿到群里跟别人讨论，出现同样的错误，对方给了另外个版本：在deletechar()函数中用malloc动态分配一块内存将str所指向的字符串复制到这块内存中，运行OK 这样改动是个办法，但，是不是成本太高了？？？说到动态分配，突然想到(就是突然想到了) [ ]，改成这个：char str[]试试看，编译，链接，运行，OK！ 怪了，怎么这样就好了？？！！有点意思，看来还得往里走走，char *str，char str[ ] 差别还挺大 反汇编！看看汇编怎么做的于是在main()里就写了两行代码char *s=&abc&;char str[]=&abccd&;看看怎么回事 char *str=&abc&; 的汇编代码mov dword ptr [ebp-4],offset string &abc& () char str[ ]=&abccd&; 的汇编代码mov eax,[string &abccd& (0046f02c)]mov dword ptr [ebp-0Ch],eaxmov cx,word ptr [string &abccd&+4 ()]mov word ptr [ebp-8],cx 乍一看，不一样！行数不一样，嘿嘿。开个玩笑有意思，继续分析看着这几行代码半天，没看明白不一样在哪里(行数除外 :D ) mov dword ptr [ebp-4],offset string &abc& () 是把&abc&的偏移量(指针)给了指针变量str，即str中的值是下面这几行干嘛了？ 看看内存，寄存器怎么变化的mov eax,[string &abccd& (0046f02c)] 把abcc四个字符存到寄存器eax中，然后写到内存[ebp-0ch](我的机器上[ebp-0ch]是0013ff74(偏移量)，str是偏移量为0013ff74的内存开始处)。 再看看上面的mov指令，是取偏移量(mov dword ptr [ebp-4],offset string &abc& ())，这里是把串&abccd&所在内存中的值复制到str开始的内存处。
到这里，问题开始清楚了：char *s=&abc&;char str[]=&abccd&; 1、char *s=&abc&; 看这个赋值： 右边，是&abc&，是个字符串常量，存在于内存某处(我的机器上是ds:0x)，程序员不知道，编译器安排的，也没必要知道(当然，这个赋值之后，程序员就知道并能控制这个串了)。字符串常量所在内存是只读的。
左边，字符指针s，赋值时候，把地址ds:0x的偏移地址(&abc&所在)，存放到指针变量s(其地址为 ds:0x)中。程序员能完全控制的内存只是指针变量所占据的这四个字节内存，只能改变该指针的指向，至于其指向的内存能不能写，那就看程序了，本程序是指向的只读内存，不能写！ 2、char str[]=&abccd&; 再看这个赋值： 右边，和上面类似，是&abccd&，也是个字符串常量，存在于内存某处(是ds:0x0046f02c)，程序员不知道，编译器安排的(这个赋值之后，程序员还是不知道这个常量在哪里，因为并没有用指针指向这块内存，这和上面不同)。该字符串常量所在内存也是只读的。
左边，字符数组str，赋值时候，把地址ds:0x0046f02c(&abccd&所在)所指内存中的内容，复制到字符数组str开始(其地址为 ds:0x0013ff74)的内存中，每复制一个字符都会开辟一个字节(char型变量占1字节)内存来存放这个字符(这也是实现了数组元素个数的动态确定)。从字符数组str开始的这部分存放这些字符的内存是程序员可以完全控制的，可读写，因此在这些内存写当然是没有问题的！
到这里，突然想到多年前看过的一本书《C和指针》(Kenneth A. Reek著，徐波 译，现在有第二版了￥65，第一版￥55，不便宜，但是是好书，值得研读,是研读哦，不是翻翻，当然翻翻也会有收获的)里面好像提到过这个问题，赶快拿来看看(字符数组的初始化一节)，果然这样。 o(∩_∩)o
另附， 数组名和指针的区别与大家分享下 原文/4728674.html 许多程序员对数组名和指针的区别不甚明了，他们认为数组名就是指针，而实际上数组名和指针有很大区别，在使用时要进行正确区分，其区分规则如下：规则1 数组名指代一种数据结构，这种数据结构就是数组； char str[10]; char *pStr = cout && sizeof(str) && cout && sizeof(pStr) && 输出结果为： 10 4 这说明数组名str指代数据结构char[10]。规则2 数组名可以转换为指向其指代实体的指针，而且是一个指针常量，不能作自增、自减等操作，不能被修改； char str[10];
char *pStr = str++; //编译出错，提示str不是左值 pStr++; //编译正确规则3 指向数组的指针则是另外一种变量类型（在WIN32平台下，长度为4），仅仅意味着数组的存放地址；规则4 数组名作为函数形参时，在函数体内，其失去了本身的内涵，仅仅只是一个指针；很遗憾，在失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。例如：void arrayTest(char str[]){cout && sizeof(str) && //输出指针长度 str++; //编译正确 }int main(int argc, char* argv[]){ char str1[10] = &I Love U&; arrayTest(str1);
return 0;}本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/lzpaul/archive//2884095.aspx
回答者:马承君
Mail: Copyright by ；All rights reserved.数组与指针的问题，如下程序，求解释_百度知道
数组与指针的问题，如下程序，求解释
n&str+7是怎么理解的;main(){char str[ ]=&tomeetme&stdio，而str+7等于'}程序中的第四行;e'\，p&p+=2) putchar(*p);; for(p=str.h&str+7;p<,*p？p是一个指针变量;; printf(&)#include<
提问者采纳
;%d&;.com/zhidao/wh%3D600%2C800/sign=fe3df8dcd100baaefc2e5d;; &&;;;&%d&}&e'}//p&,p);str+7;;main(){char&.jpg" target="_blank" title="点击查看大图" class="ikqb_img_alink"><img class="ikqb_img" src=";; putchar(*p)，*(str+7)才是');;);\n&printf(&;tomeetme&&&&;，是对地址的值进行的判断//str+7是‘e’这个字母的地址;\n&]=&p+=1)&printf(&;&.;;str+7也是地址;for(p=.jpg" esrc="http.://d;\n&;str+7中p是地址&;; printf(".;printf(&str[&;);;; &;;putchar(*p)#include&printf(& printf(&.com/zhidao/wh%3D450%2C600/sign=72e4d117b21bbc034af682/9e3df8dcd100baaefc2e5d.baidu.hiphotos
提问者评价
其他类似问题
5人觉得有用
为您推荐：
其他8条回答
p是一个动态变动的指针，而str是数组的起始地址str+7是‘e'的地址而不是字符而*p就是指p指向的字符p+=2是指每次移动两位但是不超过第七个(p&str+7)
首先，对于数组名的理解，你出了问题，str是一个字符型指针的常量，str+7也就是横跨了7个单元格，表示的是‘e'的地址，其次，对于指针的大小判断的含义是，p&q达标p在q的前面，反之，p在q的后面。
而你说的str+7不是具体元素的值，而是元素的地址，如果这样 *（str+7）才是真正的元素值 e
p在此保存的是 指针内存地址，内存地址是个连续的整数值，就类似门牌号一样。p=表示p 保存了数组开头的地址(假设为），然后 p&str+7表示 p小于 开头地址再加上7后所代表的地址，就是p&就是p&.这样 ， for语句的意思就是 p 从字符串数组str头地址开始 依次指向字符串数组前七个以内的 字符地址，然后依次输出
int 等于指针str是数组名 在算术操作中可隐式转换为指针所以str
7是'e'的地址 *(str
7)是'e'
指针p是动态指针，指的是一个地址，str值得是数组str[]中的str[0]对应的地址，随意地址可以进行偏移即+n，表示相对于[0]位置的偏移位数，p=str即是将str所指的地址赋值给p,这样p开始指的位置也就是str[0]了，p+=2就是在str[0]这个位置上每次+2
额，这是最基本的问题了，楼主稍微看看谭哥的指针那章即可解惑。
p是一个指针，P&str+7，其实就表示只要指针p的地址小雨str+7，循环就执行。相当于循环会执行7次。
str+7 是地址， p 开始指向的也是str的地址，其实都是数字
您可能关注的推广
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁蓬莱仙羽 的BLOG
用户名：蓬莱仙羽
文章数：533
评论数：71
访问量：30914
注册日期：
阅读量：5863
阅读量：12276
阅读量：316365
阅读量：1029226
51CTO推荐博文
一、& 选择题
1. 声明语句为int a[3][4]; 下列表达式中与数组元素a[2][1]等价的是(
A、*(a[2]+1)&&&&& B、a[9]&& C、*(a[1]+2)&&&&&&&& D、*(*(a+2))+1
&a[2] &==& *(a+2)是等价的
C两个数反过来了，D、1放进去
2.请问经过表达式a = 5 ? 0 : 1的运算，变量a的最终值是（ C ）
A．6&&&&&&B．1&&&&&& C．0&&&&&& D．true
3. 下面不能正确将字符串“car”进行完整赋值操作的语句是(& D
A、char s[]=&car&;&
B、char s[]={'c','a','r','\0'};&&&
C、char *s=&car&;&&
D、char s[]={&car&};
D、应该char s[][]={&car&}
4. 下列程序的输出结果是（ D &）
&&& char p1[15]=“abcd”，*p2=“ABCD”， str[50]=“xyz”；
&&& strcpy（str+2，strcat（p1+2，p2+1））；
& &&printf（“%s”，str）；
A、xyabcAB &&&&B、abcABz &&&&C、 ABabcz &&&&D、 xycdBCD
strcat是字符串的拼接，strcpy是字符串的拷贝
5. 设有如下的程序段
&char*ptr=NULL;
&&&&&&& &char str[]=&Hello&;
&&&&&&& &ptr=
执行完上面的程序段后，*(ptr+5)的值为（& B ）
A、'o'&&&&&&&&&& &&&&&&&&&&& B、'\0'&&&&&&&&
C、不确定的值&&&&&& &&&& D、'o'的地址&
字符串有‘\0’
6. 假如指针p已经指向某个整型变量x，则(*p)++相当于（ B&& ）
A、p++ &&&&&B、x++ &&&&&C、*(p++)& &&&D、&x++
7. 有声明及定义如下：
struct student
char name[20];
structstudent *p=&stu1;
&则下面对stu1中的成员num表示错误的是（ B& ）
A、stu1.num&&&& B、stu1-&num&&&&C、(*p).num&&& D、p-&num&
8. 若有说明：int *p,m＝5，n;以下正确的程序段是（ D& ）
A、p=&n; scanf(“%d”,＆p);&
B、p=&n; scanf(“%d”,*p);&&
C、scanf(“%d”,&n); *p=n; & & & & //p不知道等于多少
D、p=&n;&*p=m;
A.B直接写p
9. 下面程序段的运行结果是（ C& ）
{& char *s =”abcde”;&
&&&&&&& s+=2;&&
printf(“%d”,s);&
A、cde& &&&&&&&&&&&&&&&&&&&& B、字符’c’ &&&
C、字符’c’的地址&&&& & &&&&D、无确定的输出结果
10. 以下程序：
&&& #include&stdio.h&
&&& void main()
&&&&&&&&&&&&
&&&&&&&&&&&& scanf(”%c”,&grade);
&&&&&&&&&&&& switch(grade)
&&&&&&&&&&&& case ’A’: printf(”优秀”);
&&&&&&&&&&&& case ’B’: printf(”良好”);
&&&&&&&&&&&& default:printf(”中等”);
如果输入’A’，问输出什么（ C& ）
A、优秀&&& & B、优秀良好& & & C、优秀良好中等&&&&& D、都不是
缺少break；
修改：如果将default移动到最上面还是会往后面继续执行
C++：
1.&&下列关于this指针的说法正确的是（& &B&&& ）
A）this指针存在于每个函数之中
B）在类的非静态函数中this指针指向调用该函数的对象
C）this指针是指向虚函数表的指针
D）this指针是指向类的函数成员的指针
2.&&在下列关于C++函数的叙述中，正确的是（& C&&& ）
A）每个函数至少要有一个参数& B）每个函数都必须返回一个值
C）函数在被调用之前必须先声明&&& D）函数不能自己调用自己
3.&&下列情况中，哪一种情况不会调用拷贝构造函数 （& &B &&&）
A）用派生类的对象去初始化基类对象时
B）将类的一个对象赋值给该类的另一个对象时 & & & &//不会初始化或者创建新的
C）函数的形参是类的对象，调用函数进行形参和实参结合时
D）函数的返回值是类的对象，函数执行返回调用者时
拷贝构造函数只有在拷贝构造新的对象的时候才会调用，如果是先存在的的对象，然后进行复制，这时是不会调用拷贝构造函数的。
例如：object obj1；
& & object obj2 = obj1; &这就会调用拷贝构造函数
如果是 object obj2；obj2 = obj1；这时只会调用=号的运算符重载，不会调用拷贝构造函数
4.&&下面的程序段的运行结果为（&& D&&& ）
charstr[] = &job&, *p =
cout&& *(p+2) &&
A）98&& && B）无输出结果&&&& C）字符’b’的地址&&&&D）字符’b’
*(p+2) &==&p[2]
5.&&下面程序的输出结果是（&& &C&& ）
#include&iostream&
&& & Base(inti) { cout && }
&& & ~Base() { }
classBase1: virtual public Base
&& & Base1(inti, int j=0) : Base(j) { cout && }
&& & ~Base1(){}
classBase2: virtual public Base
&& & Base2(inti, int j=0) : Base(j) { cout && }
&& & ~Base2(){}
classDerived : public Base2, public Base1
&& & Derived(inta, int b, int c, int d) : mem1(a), mem2(b), Base1(c),
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& Base2(d),Base(a)
&&& { cout && }
& private:
&& & Base2mem2;
&& & Base1mem1;
voidmain() { Derived objD (1, 2, 3, 4); }
A）134122&&&&&& B）123412&&&&&&& C）&&&&& D）143212
先Base(a),虚基类只构建一次，防止重复构建
6.&&下面程序的输出结果是（& C&&&& ）
#include &iostream&
class Base
&& & virtual void f() { cout && “f0+”; }
&& & void g() { cout && “g0+”; }
class Derived : public Base
&& & void f() { cout && “f+”; }
&& & void g() { cout && “g+”; }
void main() { D& Base *p = &d;& p-&f();&p-&g(); }
A）f+g+&&&& B）f0+g+ C）f+g0+ D）f0+g0+
首先是在base类中去找，如果有virtual的话看子类里面有没有同名方法，如果有就用子类的，如果方法没有virtual，那就用父类的这个方法
7.&&下面程序的输出结果是（&& C &&&）
#include&iostream&
classSample
&& friend long fun (Sample s)
&&& if (s.x & 2) return 1;
&&& return s.x * fun(Sample(s.x-1));
&& &Sample(long a) { x = }
& private:
voidmain()
& int sum = 0;
& for (int i=0; i&4; i++)
&&& sum += fun(Sample(i));
}A）12&&&&& B）16&&&&&&& C）10&&&&&&& D）34
<span style="color:#ff;1+2+6=10
8.&&下列关于虚基类的描述中，错误的是(C)
A.&& 使用虚基类可以消除由多继承产生的二义性
B.&& 构造派生类对象时，虚基类的构造函数只被调用一次
C.&& 声明 class B:virtual public A 说明类B为虚基类
D.&& 建立派生类对象时，首先调用虚基类的构造函数
9.&&有下类定义
A():a(0){}
A(char*aa) {//把aa所指字符串拷贝到a所指向的存储空间
A=___________________;
Strcpy(a,aa);
~A(){delete []}
正确的选择是（A）
A. new char[strlen(aa)+1]&&&& B.char[strlen(aa)+1]
C.char[strlen(aa)]&&&&&&&&&& D. newchar[sizeof(aa)+1]
new和delete会调用构造和析构函数
malloc和free只会根据大小来开辟空间
10.&假定AA为一个类，inta()为该类的一个成员函数，若该成员函数在类定义体外定义，则函数头为（
A）int AA::a( )&&&&& B） int AA:a()
C）AA::a()&&&&&&&&&& D） AA::int a()
11.&有如下程序：
#include&iostream&
classTest{
~Test(){cout&&'#';}
intmain(){
Test& temp[2], *pTemp[2];
执行这个程序输出星号（#）的个数为（B ）。
A）1&& B）2&& C）3&& D）4
指针的是指向两个对象并没有创建对象，而数组是保存创建的对象&
12.&有如下程序：
#include&iostream&
classMyClass{
MyClass(inti=0){cout&&1;}
MyClass(constMyClass&x){cout&&2;}
MyClass&operator=(const MyClass&x){cout&&3; return *}
~MyClass(){cout&&4;}
intmain(){
MyClassobj1(1),obj2(2),obj3(obj1);
obj1=obj2;
}运行时的输出结果是（ A）。
A）1123444& B）&&& C）121444&& D）
复制的时候是调用的=运算符重载
13.&有如下程序：
&#include &iostream&
classpoint
point(){ number++;}
~point(){number--;}
& int point::number=0;
& void main()
& { point*
&&& pointA,B;
&&& point*ptr_point=new point[3];
&&&&&ptr=ptr_
& point C;
& delete[]
cout&&point::
程序结果为(A)
& A）3&& B）4&& C）6&& D）7
1.NSString *aa = @&Simple Audio Engine&;NSLog(@&%@&,[aa substringToIndex:8]);会输出（&C ）？
A.Simple Au&&&&& B.A&&&&&C.Simple A&& &&D.u
这里 还是从0开始，但是截取到它之前
如果是substringFromIndex这是包括当前这个的
2.多态的定义是（ B ）
&&& A._来自不同对象可以接受同一消息的能力&&&&&
&&& B.来自不同类的对象可以接受同一消息的能力&&&&&
&&& C.来自不同的类可以接受同一消息的能力&&&
&&& D.以上都不是
3.已知 char s[20],*p=s,则在下列语句中，错误的是（&B ）。
&&& A.p=s+5&&&&&&&&&&&&&&&&&&&&& B.s=p+s
&&& C.s[2]=p[4]&&&&&&&&&&&&&&&&& D.*p=s[0]
<span style="color:#. 以32位C++程序，请计算sizeof的值 (&C&)
&&&&&& void Func ( char str[100] )& {& sizeof( str ) = ?&}&
void*p = malloc( 100 );
sizeof( p ) = ?;
A.8&&&&&&&&&&&& 100&&&&&&&&&&&&& B. 4&&&&&&&&&&&& 100
C.4&&&&&&&&&&&& 4&&&&&&&&&&&&&&& C. 100&&&&&&&&&& 100
5.@[@&a&,@&b&];该类型是( &C &)
&&&&& A._字符串对象&&&&& B.字典对象&&&&& C.数组对象&&& D.集合对象
6. NSString *str =@&a123&; NSLog(@&%@&,(str ==@&123&)?@&yes&:@&no&);会输出(B& )
&&&&& A. yes&&&&&B. no&&&&& C.不确定&& D.错误
7.NSString *str =@&a123&;NSLog(@&%d&,[str intValue]);会输出(
&&&&& A.0&&&&&B.123&&&&& C.123a&&& D.不确定
8.int a = 0;-+a--; NSLog(@&%d&,a);会输出( B& )
&&&&& A.0&&&&&B.-1&&&&& C.1&&& D.不确定
9. Person *person =[[Person alloc]initWithObjects:@&11&, nil];
&&&&& [person release];
&&&&& NSLog(@&%d&,person.retainCount);会输出( C )
&&&&& A.0&&&&&B.-1&&&&& C.1&&& D.错误，直接崩溃
虽然释放了，但是在执行下一段代码的时候还没来得及释放，所以还是1，如果中间还有代码，就会被释放了，在执行retaincount就会选D
10. 以下关于子类和父类的叙述中，正确的是( A& )
A.代码中使用父类对象的地方,都可以使用子类对象进行替换
B.代码中使用子类对象的地方，都可以使用父类对象进行替换
C.父类定义的对象与子类定义的对象在属性和方法上一定相同
D.父类定义的对象与子类定义的对象在属性和方法上一定不同
二、& 选择题
1. a是整型变量，则执行表达式a=25/3%3后a的值为&& 2&
2. 执行下列语句:int a=1, b=2; a=a+b; b=a-b; a=a-b; printf(&%d , %d \n&, a,b );的输出结果分别是&&2，1&&&&&&&
3. inta=24; printf(&%o &, a );输出结果是& &30&&&&
4. 当a=3,b=2,c=1时，表达式f=a&b&c的值是 ：&&&& 0&&&。先计算a&b 然后是1，在1&c，结果是0
5.若有定义：inta[2][3]={2,4,6,8,10,12}；则*(&a[0][0]+2*2+1)的值是：&& 12&&
C++:
1.用递归法求从1到n的立方和：
&&&&&& f(1)=1&&&&&&&&&&&&& (n=1)
&&&&&& f(n)=f(n-1)+n3&&&& &&(n&1)
#include&iostream&
int f(int);
int main(){
&cout&&&input the number n:&;
&s=&&&&&f(n)&&&& ;
&cout&&&The result is&&&s&&
&return 0;
int f(int n){&& //递归法求立方和函数
&if (&&& n==1&&& ) &&return 1;
&else&& return (& &f(n-1)+n*n*n &&);
2. 请将下列程序补充完整，使得输出结果为“Destructor Derived DestructorBase”。
#include &iostream&
class Base
&& & & &&virtual&& ~Base ()&&&& { cout && “DestructorBase”&& }
class Derived : public Base
&& & ~Derived(){ cout && “Destructor Derived”&& }
void main ()
&&& Base*pBase = new D
&&& &&&&delete pBase&&&&&&& ;
1、变量分为全局和局部两种，_____局部变量________变量没有赋初值时，其值是不确定的。
2、使用const语句定义一个标识符常量时，则必须对它同时进行____.初始化._______。
3、objective-c中定义静态方法使用是什么修饰符____+____.
4、objective-c中是否有私有方法_____否___(是/否),它可以用什么方法来代替____类别.___.
//只有静态方法和实例方法
5、objective-c&&对象的创建：&&&& 类名& 对象指针=[[类名& alloc] 初始化方法];
6.void GetMemory(char *p, int num)
p = (char *)malloc(sizeof(char) * num);
void Test(void)
char *str = NULL;
GetMemory(str, 100);
strcpy(str, &hello&);
运行结果以及现象:______ coredump_______.
修改:______GetMemory(&str,100);_______.
三、问答题
1.建立一个结构体数组，有10个元素。成员有两个，一个是char name[30]，一个是号码int number.每个人的姓名可以通过各种方式输入。每个人的号码通过随机数获得（范围是1~1000,真随机，不能每次运行结果都一样），并打印。
struct Person
&&& char name[30];
main(int argc,constchar * argv[])
&&& srand(time(NULL));
&&& struct Person persons[10];
&&& for (int i =0; i &sizeof(persons)/sizeof(struct
Person); i++) {
&&&&&&&persons[i].number = rand()%1000+1;
&&&&&&& cout&& &输入第& && i &&&个姓名:&
&&&&&&& cin && persons[i].
&&& for (int i =0; i &sizeof(persons)/sizeof(struct
Person); i++) {
&&&&&&& cout && &姓名：& && persons[i].name&&&号码:&&
&& persons[i].number &&
C++:
1.编写类String的构造函数、析构函数和赋值函数，已知类String的原型为：
class&String
String(const&char&*str&=&NULL);&//&普通构造函数&
String(const&String&&other);&//&拷贝构造函数&
~&String(void);&//&析构函数&
String&&&operate&=(const&String&&other);&//&赋值函数&
private:
char&*m_&//&用于保存字符串&
//普通构造函数
String::String(const&char&*str)
if(str==NULL)
m_data&=&new&char[1];&//&对空字符串自动申请存放结束标志'\0'的空
*m_data&=&'\0';//加分点：对m_data加NULL判断
int&length&=&strlen(str);
m_data&=&new&char[length+1];&//&若能加NULL判断则更好&
strcpy(m_data,str);
//&String的析构函数
String::~String(void)
delete [] m_&//&或deletem_
//拷贝构造函数
String::String(const&String&&other)&//&输入参数为const型
int&length&=&strlen(other.m_data);
m_data&=&new&char[length+1]; //对m_data加NULL
strcpy(m_data,other.m_data);
//赋值函数
String&&&String::operate&=(const&String&&other)&//输入参数为const型
if(this&==&&other) return&*//检查自赋值
delete [] m_ //释放原有的内存资源
int&length&=&strlen(other.m_data
m_data&=&new&char[length+1]; //对m_data加NULL
strcpy( m_data,other.m_data );
return&* //返回本对象的引用
2.分别给出BOOL，int，float，指针变量与“零值”比较的 if 语句（假设变量名为var）
BOOL型变量：if(!var)
int型变量：if(var==0)
float型变量：
const float EPSINON =0.00001;
if ((x &= - EPSINON)&& (x &=EPSINON)
指针变量： if(var==NULL)
3.New，delete&与malloc &，free&的联系与区别?
答案：都是在堆(heap)上进行动态的内存操作。用malloc函数需要指定内存分配的字节数并且不能初始化对象，new 会自动调用对象的构造函数。delete 会调用对象的析构函数，而free 不会调用对象的析构函数.
4.将“引用”作为函数参数有哪些特点？
（1）传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。
（2）使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效率和所占空间都好。
（3）使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用&*指针变量名&的形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。
5.& .h头文件中的ifndef/define/endif的作用？
答：防止该头文件被重复引用。
1.&&&&定义属性时，什么情况使用copy、assign、retain？
assign用于简单数据类型，如NSInteger,double,bool,
retain和copy用于对象，
copy用于当a指向一个对象，b也想指向同样的对象的时候，如果用assign，a如果释放，再调用b会crash,如果用copy的方式，a和b各自有自己的内存，就可以解决这个问题。
retain 会使计数器加一，也可以解决assign的问题。
另外：atomic和nonatomic用来决定编译器生成的getter和setter是否为原子操作。在多线程环境下，原子操作是必要的，否则有可能引起错误的结果。
加了atomic，setter函数会变成下面这样：
if (property !=newValue) {
[property release];
property = [newValueretain];
2.&&&&#import和#include的区别，@class代表什么？
@class一般用于头文件中需要声明该类的某个实例变量的时候用到，在m文件中还是需要使用#import，而#import比起#include的好处就是不会引起重复包含
3.&&&&Object-C有私有方法吗？私有变量呢？
objective-c C 类里面的方法只有两种,静态方法和实例方法.这似乎就不是完整的面向对象了,按照OO的原则就是一个对象只暴露有用的东西.如果没有了私有方法的话,对于一些小范围的代码重用就不那么顺手了.在类里面声名一个私有方法
@interface Controller: NSObject { NSString * }
+(void)thisIsAStaticM
C (void)thisIsAnInstanceM
@interface Controller(private) C
(void)thisIsAPrivateM@end
@private可以用来修饰私有变量
在Objective\C中，所有实例变量默认都是私有的，所有实例方法默认都是公有的
4.&&&& 阐述一下 person.money=100; 和 int num = person.money 的区别
答：前者调用的是setter方法，而后者调用的是getter方法
5.&&&& 定义一个类实现NSCoding 和 NSCopying 并实现
- (void) encodeWithCoder:(NSCoder*)encoder {&
&&&&&[encoder encodeObject:_title forKey:kTitleKey];
&&&&&[encoder encodeFloat:_rating forKey:kRatingKey];
-(id)initWithCoder:(NSCoder *)decoder {&&
&&&& NSString *title = [decoderdecodeObjectForKey:kTitleKey];&
&&&& float rating = [decoderdecodeFloatForKey:kRatingKey];&
&&&& return [self initWithTitle:titlerating:rating];
-(id)copyWithZone:(NSZone&*)zone&&
&&&&Fraction&*newFract&=&[[Fraction&allocWithZone:zone]&init];&&
&&&&[newFract&setTo:a&over:b];&&
&&&&return&newF&&
本文出自 “” 博客，请务必保留此出处
了这篇文章
类别：┆阅读(0)┆评论(0)
