急求c++题目答案答案，非常感谢_百度知道
急求c++题目答案答案，非常感谢
急求c++题目答案：设计一个字符串类，除具有一般的输入|输出字符串的功能外，还要求具有计算字符串长度，连接两个字符串等功能。那位大神知道发我邮箱：sudalv.c供恭垛枷艹磺讹委番莲om,非常感谢
//原创 VC6.0测试过#include &iostream.h&#include &string.h&class MyString{public: MyString();
//无参数构造函数
MyString(const MyString &c); //复制构造函数
MyString(char *p);
//有参构造函数
void SetString(char *p);
//设置字符串
int GetLength();
//返回字符串长度
MyString Ltrim();
//去除左边空格
MyString Rtrim();
//去除右边空格
MyString StrLink(char *p);
//连接字符串
MyString StrLink(MyString &c);
//连接字符串
MyString Ucase();
//将字符串中的所有小写字母转为大写字母
MyString Lcase();
//将字符串中的所有大写字母转为小写字母
MyString DelChar(char ch);
//删除字符串中所有出现的指定字符 char * ToString();
//返回字符数组 MyString operator = (char *p); MyString operator = (const MyString one); MyString operator +=(char *p); MyString operator + (char *p); MyString operator + (const MyString one); friend MyString operator + (char *p,const MyString one);
~MyString();
//析构函数 private: char * int array_ //字符数组长度 int str_
//字符串实际长度};MyString::MyString(){
this-&str=new char[1];
this-&str_len=1;
this-&array_len=0;}MyString::MyString(char *p){ int i=0;
while(*(p+i)!='\0') {
i++; } this-&str=new char[i+1]; this-&array_len=i+1; this-&str_len=i; for(int j=0;j&array_j++) str[j]=*(p+j);}MyString::MyString(const MyString &c){
this-&array_len=c.array_
this-&str_len=c.str_
str=new char[this-&array_len];
for(int i=0;i&this-&array_i++)
this-&str[i]=c.str[i];}void MyString::SetString(char *p){ if(this-&str) delete [] this-& int i=0;
while(*(p+i)!='\0') {
i++; } this-&str=new char[i+1]; this-&array_len=i+1; this-&str_len=i; for(int j=0;j&array_j++) str[j]=*(p+j);}int MyString::GetLength(){
return this-&str_}MyString MyString::operator =(const MyString one){
SetString(one.str); return *}MyString MyString::operator +(char*p){
MyString one=this-&StrLink(p);}MyString MyString::operator +=(char *p){
*this=this-&StrLink(p); return *}MyString MyString::DelChar(char ch){ int count=0; char * tmp=new char[array_len];
for(int i=0,j=0;i&array_i++)
if(str[i]!=ch)tmp[j++]=str[i];
} MyString * oneString=new MyString(tmp); delete [] return *oneS}MyString operator+(char *p,const MyString one){
char *tmp=new char[strlen(p)+one.array_len];
for(;i&(int)strlen(p);i++)
tmp[i]=p[i];
for(int j=0;j&one.array_j++)
tmp[i++]=one.str[j];
return *(new MyString(tmp));}MyString MyString::operator +(const MyString one){
return *this+one.}MyString MyString::StrLink(MyString &c){
return *this+c.ToString();}MyString MyString::StrLink(char *p){ char *tmp=new char[array_len+strlen(p)];
int i=0; for(;i&array_len-1;i++) {
tmp[i]=str[i]; } for(int j=0; j&=(int)(strlen(p)); j++,i++) {
tmp[i]=p[j]; } return *(new MyString(tmp));}MyString MyString::Lcase(){
MyString *oneString=new MyString(*this);
for(int i=0;i&array_i++)
if(str[i]&=65 && str[i]&=90)
oneString-&str[i]+=32;
return *oneS}MyString MyString::Ucase(){
MyString *oneString=new MyString(*this);
for(int i=0;i&array_i++)
if(str[i]&=97 && str[i]&=122)
oneString-&str[i]-=32;
return *oneS}MyString MyString::Ltrim(){ MyString *oneString=new MyString(*this);
char *tmp=new char[array_len]; bool go= for(int i=0,j=0;i&array_i++) {
if(str[i]!=32)go=
tmp[j++]=str[i]; } oneString-&SetString(tmp); delete []
return *oneS}MyString MyString::Rtrim(){
char *tmp=new char[array_len]; for(int i=0;i&array_i++) {
tmp[i]=str[i]; }
for(int j=array_len-2;j&0;j--)
if(tmp[j]==' ')tmp[j]='\0';
} MyString one(tmp); delete []}MyString::~MyString(){
if(this-&str) delete [] this-&}char* MyString::ToString(){
return this-&}int main(int argc, char* argv[]){ MyString str1(&wangaochao&); //初始化str1 str1=str1.DelChar('o');//删除'o' str1.str=&wangacha&
MyString str2; str2.SetString(& and dengxiaoqin&); str1=str1.StrLink(str2);
//对象相连接str1.str=&wangacha and dengxiaoqin& //也可以用str1=str1+str2; 或 str1+=都可以达到同相的效果
MyString str3=str1.StrLink(& are teachers.&); //str3.str=&wangacha and dengxiaoqin are teachers.& //MyString str3=str1+& are teachers.&可以达到上面相同的效果 cout&&str1.ToString()&&
//显示 wangacha and dengxiaoqin are teachers MyString one=&you say:&+str1; //one.str=&you say:wangacha and dengxiaoqin are teachers& cout&&one.ToString()&&
one=one.Ucase();//转换成大写 cout&&one.ToString()&& cout&&one.Lcase().ToString()&&//再转换成小写,但不改变one本身. one=&
&;//加上左右空格 cout&&one供恭垛枷艹磺讹委番莲.ToString()&&&right&&&//看效果 one=one.Ltrim();//去掉左右空格 one=one.Rtrim(); cout&&one.ToString()&&&right&&&//看效果 cout&&one.GetLength()&&//输出字符数 return 0;}
来自团队：
其他类似问题
为您推荐：
感谢的相关知识
其他3条回答
1.编一个使用派生类的程序，使一个包含圆和圆柱的几何尺寸的类，
它使用内部数据建立几何形状并显示它们的尺寸.面积和体积。
2.设计一个平面几何中点的位置类position，该类至少提供移动，
求到另一点的距离（包括到原点的距离），求x坐标，求y坐标等
操作。编一主函数检查它们。
#include &stdio.h&
#include &math.h&
class Circle
//获取面积
float GetArea()
return 3. * r *
//输出半径,面积
virtual void ShowMsg()
printf(&圆的半径为 %f ,面积为 %f\n&,r,GetArea());
//圆柱类,从圆派生,多一个高度
class Cylinder : public Circle
c++有一个string类，你可以参照其源码
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁您所在位置： &
&nbsp&&nbsp&nbsp&&nbsp
c++期末复习题.doc25页
本文档一共被下载：
次 ,您可免费全文在线阅读后下载本文档
文档加载中...广告还剩秒
需要金币：200 &&
你可能关注的文档：
··········
··········
一、 填空题（每空1分，共15分，将正确答案写在（
1.C++中有两种数据类型：
可以使用signed修饰符。
在C++中，用数组、指针、和
作为函数参数，能够将参数值带回。
2.为了降低函数调用的时间开销，建议将小的调用频繁的函数定义为（内联函数 ），方法是在函数类型前加上（ inline ）关键字。
3.面向对象的程序设计有四大特征，它们是抽象、封装、
4.拷贝构造函数是在用一个对象初始化另一个对象时被调用，系统缺省的拷贝构造函数的工作方法是
拷贝每一个数据成员
。或逐一拷贝
5.用new申请某一个类的动态对象数组时，在该类中必须能够匹配到
构造函数，否则应用程序会产生一个编译错误。
6.静态数据成员必须在类外进行初始化，且静态数据成员的一个拷贝被类的所有对象
7.在C++中，定义重载函数时，应至少使重载函数的参数个数或参数类型
有一个不同
8.在C++中，虽然友元提供了类之间数据进行访问的一种方式，但它破坏了面向对象程序设计的
9.预编译指令由三种，它们是：文件包含、
宏定义 （条件编译）
10.静态的成员函数没有隐含的
，所以，它们只能直接访问类的静态的数据成员。
11.在C++中，函数的参数有两种传递方式，它们是值传递和
12.当非静态成员函数被调用时，该成员函数的
指向调用它的对象。
13.拷贝构造函数使用
一个已经存在的对象
作为参数初始化创建中的对象。
14.在公有继承的情况下，基类数据成员在派生类中的访问权限
15.在C++中，构造派生类对象时，总是先从（ 基类
的初始化开始的。
16.当需要统
正在加载中，请稍后...求大工13秋《C/C++语言程序设计》在线作业2一、单选题（共 10 道试题,共 50 分.）V1.当一个类对象离开它的作用域时,系统将自动调用该类的（ ）.A.构造函数B.拷贝构造函数C.析构函数D.默认构造函数满分：5 分2.说明类中保护成员的关键字是（ ）.A.privateB.publicC.protectedD.friend满分：5 分3.类中将关键字（ ）写在函数体之前函数头之后,说明该函数是一个常成员函数（或const成员函数),可以防止函数改变数据成员的值.A.constB.staticC.friendD.void满分：5 分4.下列哪个函数的作用是字符串比较（ ）.A.strlen()B.strcmp()C.strcat()D.strcpy()满分：5 分5.下列哪个函数不是类的成员函数.（ ）A.析构函数B.构造函数C.拷贝构造函数D.友元函数满分：5 分6.下列哪个函数的功能是对对象进行初始化.（ ）A.析构函数B.数据成员C.构造函数D.静态成员函数满分：5 分7.在定义int a[5]；之后,对a的引用正确的是（ ）.A.a[5]B.a[4.3]C.a(5)D.a[0]满分：5 分8.说明类中私有成员的关键字是（ ）.A.privateB.publicC.protectedD.friend满分：5 分9.执行下面的程序段后,输出结果是（ ）.main(){char a[]="english";printf("%c",a[0]);}A.engliB.eC.englishD.sh满分：5 分10.在执行int a[][3]={1,2,3,4,5,6}；语句后,a[0][0]的值是（ ）.A.4B.1C.2D.5满分：5 分——————————————————————————————————————————二、判断题（共 10 道试题,共 50 分.）V1.友元函数的关键字const.（ ）A.错误B.正确满分：5 分2.说明静态数据成员时,前边要加关键字static.（ ）A.错误B.正确满分：5 分3.作用域运算符的功能是标识某个成员是属于哪个类.（ ）A.错误B.正确满分：5 分4.析构函数的功能是对对象进行初始化.（ ）A.错误B.正确满分：5 分5.关键字中,用以说明类中公有成员的是private.（ ）A.错误B.正确满分：5 分6.一个类只能有一个对象.（ ）A.错误B.正确满分：5 分7.拷贝构造函数不是类的成员函数.（ ）A.错误B.正确满分：5 分8.成员函数可以重载.（ ）A.错误B.正确满分：5 分9.strcat()函数的作用是求字符串长度.（ ）A.错误B.正确满分：5 分10.delete的功能是动态分配内存.（ ）A.错误B.正确满分：5 分
好吧,我还是自己做：1.c2.c3.a4.b5.d6.c7.d8.a9.b10.b二1A2B3B4A5A6A7A8B9A10A
为您推荐：
其他类似问题
扫描下载二维码下面这些题目都是我之前准备笔试面试过程中积累的，大部分都是知名公司的笔试题，C++基础薄弱的很容易栽进去。我从中选了10道简单的题，C++初学者可以进来挑战下，C++大牛也可以作为娱乐玩下（比如下面的第6题）。为了便于大家思考，将题目与答案分开，不过无论题目本身如何，我觉得后面的解析过程更值得学习，因为涉及很多我们学习C++过程中必知必会的小知识点 。
第一部分：题目
如下函数，在32 bit系统foo(2^31-3)的值是：（）
int foo(int x)
return x&-x;
A：0 B: 1 C: 2 D: 4
运算符优先级
unsigned char i=0x80;
printf("0x%x\n", ~i&&3+1);
输出什么？
静态对象是否调用构造函数？
#include &iostream&
using namespace
A() { cout && "A's Constructor Called " &&
B() { cout && "B's Constructor Called " && }
int main()
#include &stdio.h&
char x[2];
int main()
a.x[0] = 10;
a.x[1] = 1;
printf("%d",a.i);
下面代码会报错吗？为什么？
void print() {
cout && "A\n";
A *pa = 0;
pa-&print();
下面代码的输出是什么？（非常考基础水平的一道题）
char *c[] = {"ENTER","NEW","POINT","FIRST"};
char **cp[] = { c + 3 , c + 2 , c + 1 , c};
char ***cpp =
int main(void)
printf("%s",**++cpp);
printf("%s",*--*++cpp+3);
printf("%s",*cpp[-2]+3);
printf("%s\n",cpp[-1][-1]+1);
#include &stdio.h&
struct data
unsigned short
int main(void)
mData.b = 0x0102;
char *pData = (char *)&mD
printf("%d %d", sizeof(pData), (int)(*(pData + 4)));
改变string变量的值？
#include &iostream&
#include &string&
using namespace
void chg_str(string str) {
str = "ichgit";
int main() {
string s = "sarrr";
chg_str(s);
printf("%s\n", s.c_str());
cout && s &&
静态变量的输出
#include &stdio.h&
int sum(int a) {
int c = 0;
static int b = 3; // 只执行一次
return (a + b + c);
int main() {
int a = 2;
for(i = 0; i & 5; ++i) {
printf("%d\n", sum(a));
返回值加const修饰的必要性
你觉得下面两种写法有区别吗？
int GetInt(void)
const int GetInt(void)
如果是下面的呢？其中A 为用户自定义的数据类型。
A GetA(void)
const A GetA(void)
第二部分：答案详细解析
如下函数，在32 bit系统foo(2^31-3)的值是：
int foo(int x)
return x&-x;
A：0 B: 1 C: 2 D: 4&
解释：我只想说注意运算符优先级，注意^是异或而不是幂次方。
运算符优先级
unsigned char i=0x80;
printf("0x%x\n", ~i&&3+1);输出什么？
输出：0xfffffff7（提示：+的优先级优于&&）
如果将unsigned去掉，则输出0x7。
静态对象是否调用构造函数？
#include &iostream&
using namespace
A() { cout && "A's Constructor Called " &&
B() { cout && "B's Constructor Called " && }
int main()
B's Constructor Called
解释：上面的程序只是调用了B的构造函数，没有调用A的构造函数。因为静态成员变量只是在类中声明，没有定义。静态成员变量必须在类外使用作用域标识符显式定义。
如果我们没有显式定义静态成员变量a，就试图访问它，编译会出错，比如下面的程序编译出错：
#include &iostream&
using namespace
A() { cout && "A's constructor called " &&
B() { cout && "B's constructor called " && }
static A getA() { return }
int main()
A a = b.getA();
Compiler Error: undefined reference to `B::a
如果我们加上a的定义，那么上面的程序可以正常运行，
注意：如果A是个空类，没有数据成员x，则就算B中的a未定义也还是能运行成功的，即可以访问A。
#include &iostream&
using namespace
A() { cout && "A's constructor called " &&
B() { cout && "B's constructor called " && }
static A getA() { return }
// definition of a
int main()
B b1, b2, b3;
A a = b1.getA();
A's constructor called
B's constructor called
B's constructor called
B's constructor called
上面的程序调用B的构造函数3次，但是只调用A的构造函数一次，因为静态成员变量被所有对象共享，这也是它被称为类变量的原因。同时，静态成员变量也可以通过类名直接访问，比如下面的程序没有通过任何类对象访问，只是通过类访问a。
int main()
// static member 'a' is accessed without any object of B
A a = B::getA();
A's constructor called
#include &stdio.h&
char x[2];
int main()
a.x[0] = 10;
a.x[1] = 1;
printf("%d",a.i);
输出：266，自己画个内存结构图就知道了，注意union的存放顺序是所有成员都从低地址开始存放。Union的大小为其内部所有变量的最大值，并且按照类型最大值的整数倍进行内存对齐。
下面代码会报错吗？为什么？
void print() {
cout && "A\n";
A *pa = 0;
pa-&print();
答案：正常输出。上面的代码可以这样理解（这非常重要）：
void print(A *this) {
cout && "A\n";
A *pa = 0;
print_A();
也就是：并不是类没有初始化就不能调用类的成员函数，如果成员函数只是简单的打印个东西，没有调用类成员啥的就不会报段错误。
下面代码的输出是什么？（非常考基础水平的一道题）
char *c[] = {"ENTER","NEW","POINT","FIRST"};
char **cp[] = { c + 3 , c + 2 , c + 1 , c};
char ***cpp =
int main(void)
printf("%s",**++cpp);
printf("%s",*--*++cpp+3);
printf("%s",*cpp[-2]+3);
printf("%s\n",cpp[-1][-1]+1);
c是一个指针数组，每个数组元素都是char*类型的指针，值分别是那些字符串(的首地址)：
c[0] = "ENTER"
c[1] = "NEW"
c[2] = "POINT"
c[3] = "FIRST"
而[]和*是本质一样的运算，即c[i]=*(c+i)。
c和c+i都是char *[]类型，它可以退化成char **类型，再看cp，它正好是一个char **的数组，来看它的值：
cp[0] = c + 3
cp[1] = c + 2
cp[2] = c + 1
引用后就有：cp[0][0]=*(c + 3)=c[3]="FIRST"，以此类推。
cp是char **[]类型，它可以退化成char ***类型，看最后的cpp，它正是char ***类型，它是一个指针变量，和上面两个不同，上面两个是数组。
这样分析过后，下面的解析就一目了然了：
printf("%s",**++cpp);
++cpp的值是cp+1，引用一次后是cp[1]再引用是*cp[1]=c[2]="POINT"，第一句的输出
printf("%s",*--*++cpp+3);
再++cpp的值是cp+2，引用一次是cp[2]=c+1，再对这进行--，减后是c再引用是c[0]="ENTER"再+3，字符串指针指到"ER"，输出是"ER"
printf("%s",*cpp[-2]+3);
这时cpp的值是cp+2，cpp[-2]=*(cpp-2)=*(cp+2-2)=cp[0]=c+3，再引用是c[3]="FIRST",+3 字符串指针指到"ST"，输出是"ST"
printf("%s\n",cpp[-1][-1]+1);
cpp还是cp+2，cpp[-1]=*(cpp-1)=*(cp+2-1)=cp[1]=c+2，再[-1]得*(c+2-1)=c[1]="NEW",+1字符串指针指到"EW"，输出是"EW"。
#include &stdio.h&
struct data
unsigned short
int main(void)
mData.b = 0x0102;
char *pData = (char *)&mD
printf("%d %d", sizeof(pData), (int)(*(pData + 4)));
输出：4 2&
说明：一般变量都是从高到低分配内存地址，但对于结构体来说，结构体的成员在内存中顺序存放，所占内存地址依次增高，第一个成员处于低地址处，最后一个成员处于最高地址处，但结构体成员的内存分配不一定是连续的，编译器会对其成员变量依据前面介绍的 &对齐&原则进行处理。
补充知识点：
除了栈以外，堆、只读数据区、全局变量地址增长方向都是从低到高的。
改变string变量的值？
#include &iostream&
#include &string&
using namespace
void chg_str(string str) {
str = "ichgit";
int main() {
string s = "sarrr";
chg_str(s);
printf("%s\n", s.c_str());
cout && s &&
输出：仍为&sarrr&。
解释：string是传值参数，不能修改其值。要想改变string变量的值，可以改为传地址方式：
#include &iostream&
#include &string&
using namespace
void chg_str(string *str) {
*str = "ichgit";
int main() {
string s = "sarrr";
chg_str(&s);
printf("%s\n", s.c_str());
cout && s &&
静态变量的输出
#include &stdio.h&
int sum(int a) {
int c = 0;
static int b = 3; // 只执行一次
return (a + b + c);
int main() {
int a = 2;
for(i = 0; i & 5; ++i) {
printf("%d\n", sum(a));
输出：8 10 12 14 16
解释：存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化，此后该初始化不再执行，相当于一次执行后就作废，静态局部变量保存了前次被调用后留下的值。
返回值加const修饰的必要性
你觉得下面两种写法有区别吗？
int GetInt(void)
const int GetInt(void)
如果是下面的呢？其中A 为用户自定义的数据类型。
A GetA(void)
const A GetA(void)
答案：没有任何区别。
解释：如果函数返回值采用&值传递方式&，由于函数会把返回值复制到外部临时的存储单元中，加const 修饰没有任何价值。所以，对于值传递来说，加const没有太多意义。
不要把函数int GetInt(void) 写成const int GetInt(void)。
不要把函数A GetA(void) 写成const A GetA(void)。
在编程中要尽可能多的使用const（比如函数参数采用const&修饰），这样可以获得编译器的帮助，以便写出健壮性的代码。
阅读(...) 评论()