c++复习

最新推荐文章于 2024-08-30 16:00:44 发布

yuitsu

最新推荐文章于 2024-08-30 16:00:44 发布

阅读量1k

点赞数 1

文章标签： c++

本文链接：https://blog.csdn.net/m0_60684612/article/details/129638160

版权

本文详细介绍了C++中的基本概念和技术，包括C语言特性、面向对象编程的原理、函数模板和类模板的使用、运算符重载的规则、继承与派生的机制、以及内存管理和对象生命周期，特别强调了虚函数和析构函数在多态性和资源释放中的重要性。

摘要由CSDN通过智能技术生成

针对期末考试的一些选择判断填空题--PTA

一、

提取符(<<)可以输出各种基本数据类型的变量的值，也可以输出指针值。√
c语言不是面向对象的
如果程序中使用了using命令同时引用了多个命名空间，并且命名空间中存在相同的函数，将出现：编译错误
面向对象程序设计主要考虑的是提高软件的：可重用性
使用操作符setw对数据进行格式输出时，需要包含（）文件。iomanip.h
cout，cin 是由I/O 流库预定义的（）。对象
cout<<fill('#') 。表达错误
cin比C语言中的scanf()函数更有优势，它可以读取空格。×

二、

逻辑运算的短路特性，是指当第一个操作数满足某种条件后，就不会再执行第二个操作数的运算。√
定义变量int i; 然后对变量i进行强制类型转换运算：double(i); 运算结束后，变量i的类型转换为double类型。 ×

设int x；，则经过（）后，语句*px=0；可将x值置为0。 c

A.int * px；
B.int const * px=&x；    //指针所指变量为const，注意是*后加const才是指针为const
C.int * const px=&x；    //指针为const
D.const int * px=&x；    //指针所指变量为const

const int* const p; const b不能放最后

函数带默认参数说明：有一个有默认参数，后面的每个都要有默认参数

默认参数不能在声明和定义中同时出现（一个有默认参数，一个没有）
输入一行：cin.getline(输入，长度)

三、

只有返回值不同不是重载函数
默认参数不能在声明和定义中同时出现（一个有默认参数，一个没有）。 x
操纵符本身是一个对象，它可以直接被提取符或插入符操作。√
get()函数不能从流中提取终止字符，终止字符仍留在流中。getline()函数可以从流中提取终止字符，但终止字符被丢弃。 √
使用打开文件函数open()之前，需要定义一个流类对象，使用open()函数来操作该对象。使用关闭文件函数close()关闭一个文件时，流对象仍存在。√
以app 方式打开文件时,当前的读指针和写指针都定位于文件尾。√
如果在函数中定义的局部变量与命名空间中的变量同名时，（命名空间中的变量）被隐藏。保留函数中的变量
如果程序中使用了using命令同时引用了多个命名空间，并且命名空间中存在相同的函数，将出现：编译错误
在一个被调用函数中，关于 return 语句使用的描述，错误的是（D）。

A.被调用函数中可以不用 return 语句

B.被调用函数中可以使用多个 return 语句

C.被调用函数中，如果有返回值，就一定要有 return 语句

D.被调用函数中，一个 return 语句可以返回多个值给调用函数 x
重载函数在调用时选择的依据中，错误的是（函数类型）。有关的是：参数名、参数类型、函数名。返回值不同不算重载。允许有默认参数。
使用地址作为实参传给形参时，实参与形参操作的是同一对象
当一个函数功能不太复杂，但要求被频繁调用时，选用。内联函数

四、

const成员函数、构造、析构函数内部可以使用this指针。
当创建一个对象后，this指针就指向该对象
常成员函数： func（）const；
一个类一定会有无参构造函数。x
2
构造函数可以是内联函数
类的实例化是指：定义对象。
一个类可以没有成员函数
//this指针 Vehicle::Vehicle(int wheels,float weight) { this->weight=weight; this->wheels=wheels; }

五、友元

某类的友元类的所有成员函数可以存取或修改该类中的私有成员。√
已知类A是类B的友元，那么类A的成员函数可以访问类B的对象的任何成员
一个类的友元函数是这个类的成员。 x
静态数据成员不能在类中初始化，使用时需要在类体外声明。 √
利用赋值语句对数组元素进行赋值时，系统先调用有参构造函数创建无名对象，并将其值赋给相应对象数组元素，然后再将无名对象释放,释放时调用析构函数。
常成员函数可以引用对象的数据成员，但是不能更新数据成员，也不能调用该类中非常成员函数。
类的非静态成员函数才有this指针

2-8以下对类A的定义中正确的是（） (2分)

A.class A{private：int v;public : void Func(){}}
B.class A{private : int v;A *next;};
C. class A{int v;public:void Func();};A::void Func(){}
D.class A{int v;public: A next;void Func(){ }};

AC缺分号，一定要注意
B（正确）class A{int v;public:void Func();};void A::Func(){}；（要注意成员函数的定义方式）
D(正确）class A{int v;public: A *next;void Func(){ }}；

一个类的私有成员函数内部不能访问本类的私有成员函数。 x
类内默认private

下面程序的运行结果为。 21

#include<iostream.h>
class A
{
  int num;
public:
  A（int i）{num=i;}
  A（A &a）{num=a.num++;} //右++
  void print（）{cout<<num;}
};
void main（）
{
  A a （1）,b（a）;
  a.print（）;
  b.print（）;
}

在C++中用类将数据和对数据操作的代码连接在一起称为（封装）。
拷贝初始化构造函数：MyClass(MyClass &x);
析构函数是系统的内置函。 x

只有用delete关键字删除对象时，系统才会自动调用析构函数。 x
下列哪一种情况下，类的复制构造函数不会被调用？

用类的一个对象赋值给另一个对象时
在创建类的一个实例之前，不可访问类的静态数据成员。x

可以通过的“对象名.静态成员名”的方式访问类的静态数据成员。 √
如果某函数的返回值是个对象，则该函数被调用时，返回的对象是通过拷贝构造函数初始化的
对于通过new运算符生成的对象，执行 delete 操作时才能析构
类A会调用析构函数几次？ 3 int main(){ A * p = new A[2]; A * p2 = new A; A a; delete [] p; }
const成员函数可以作用于非 const 对象。
友元类关系是相互的,即若类A是类B 的友元,类B也是类A的友元。 x
常数据成员必须被初始化，并且不能更新。

复制构造函数

CAT::CAT()
{    itsAge=new int;
     *itsAge =5;
}
CAT::CAT(const CAT& c){
     itsAge=new int;
    *itsAge=c.GetAge();
}

显式使用this指针

R::R(int i,int j){
    this->len=i;
    this->w=j;
}

创建、删除对象、对象数组

class A{};
int main()
{
    A *p=new A;//动态创建对象p    
    p->display();
    delete p;/删除对象p     
    p=new A(8);//调用构造函数
    p->display();
    delete p;
    p=new A[3];//p指向对象数组    
    A *q=p;
    for(int i=0;i<3;i++){
        q++->display();//输出对象数组数据   
    }
    delete []p;//删除对象数组指针p      
    return 0;
}

静态变量一定在类外声明和初始化
static在类中放在public。获取静态成员的函数设成静态函数（最前面加static）

//多种构造函数
    Point(int x , int y){
        m_x = x;
        m_y = y;
        count++;
    }
    Point(Point &a){
         m_x = a.getX();
         m_y = a.getY();
         count++;
     }
      Point(){
         m_x = 0;
         m_y = 0;
         count++;
     }
     Point(int x){
         m_x = x;
         m_y = 0;
         count++;
     }

int get_wheels(){	//get：创建一个变量用来返回
			return m_nWheels;
		}
void et_wheels(int p=0){	//set：直接赋值（this指针）			
			m_nWheels = p;
		}

六、继承

在protected保护继承中，对于垂直访问等同于公有继承，对于水平访问等同于私有继承。 √
公有继承可以实现子类型。 √
派生类D由基类A公有派生。假设基类A中有一个公有函数成员add（原型：int add (int x, int y);）；在派生类D中，派生一个公有函数成员add（原型：int add (int x, int y, int z);）；则在语句（D d；d.add(10,20)；）中，不可以正常调用add函数。 √
类的组合关系可以用“Has-A”描述；类间的继承与派生关系可以用“Is-A”描述。 √
基类中的私有成员不论通过何种派生方式，到了派生类中均变成不可直接访问成员。 √ 即派生类无法直接访问基类的私有成员，但可以调用基类的函数访问私有成员
继承关系中的子类将拥有父类的全部属性和方法
私有继承下父类的所有都变为private；保护继承全为protected；公有继承不变
如果基类声明了带有形参表的构造函数，则派生类就应当声明构造函数
构造函数的调用顺序：a(基类的构造函数)、b(成员对象的构造函数)、c(派生类的构造函数)

#include<iostream>
using namespace std;
class A {
public:
    A(int i) {    x = i;  }
    void dispa() {
        cout << x << ',';
    }
private:
    int x;
};
class B: public A {
public:
    B(int i) : A(i + 10) {
        x = i;
    }
    void dispb() {
        dispa();
        cout << x << endl;
    }
private:
    int x;
};
int main() {
    B b(2);
    b.dispb();
    return 0;
}

//12 2

一个基类可以有多个派生类x ；一个派生类可以有多个基类√
不继承构造函数和析构函数
由多个基类派生时,基类构造函数的调用顺序,取决于定义派生类时,派生列表中的基类声明顺序

class Student                              //声明基类
 {public:                                  //公用部分
   Student(int n,string nam)              //基类构造函数
    {num=n;
     name=nam;
    }
  protected:                                //保护部分
    int num;
    string name;
};

class Student1: public Student              //用public继承方式声明派生类student
 {public:   
    Student1(int n,string nam,int a,string ad):Student(n,nam),monitor(n1,nam1) 		//派生类构造函数**
    {age=a;                                 //在此处只对派生类新增的数据成员初始化
     addr=ad;
    }

记得写析构函数；如果基类的构造函数带参，派生类的构造函数的带参把基类的参加上，后面列表初始化：加基类构造函数

7-1 定义基类Point和派生类Circle，求圆的周长.

#include <iostream>
#include <iomanip>
#define PI 3.14
using namespace std;
class Point{
protected:
    float X,Y;
public:
    Point(){}
    Point(float x,float y):X(x),Y(y){	//列表初始化
        cout<<"Point constructor called"<<endl;
    }
    ~Point(){
        cout<<"Point destructor called"<<endl;
    }
};
class Circle:public Point{
    float R;
public:
    float s;
    Circle(float x,float y,float r):Point(x,y),R(r){	//！！！
        cout<<"Circle constructor called"<<endl;
    };
    ~Circle(){
        cout<<"Circle destructor called"<<endl;
    }
    float getCircumference();
};
float Circle::getCircumference(){
    s=PI*R*2;
    return s;
}
int main()
{
    float x,y,r;
    cin>>x>>y>>r;
    Circle c(x,y,r);
    cout<<fixed<<setprecision(2)<<c.getCircumference()<<endl;
    return 0;
}

七、派生

如果公有派生，派生类对象可以给基类对象赋值
如果公有派生，则可以用派生类对象给基类对象赋值。x 可以用基类对象的地址赋值给派生类的指针。x
即派生类可以赋值给/转化为基类，基类不能赋值给派生类
在C++语言中设置虚基类的目的是（）。解决多继承造成的二义性问题

class C: public B,public A
{
private:
    int c;
public:
    C(int k):A(k-2),B(k+2) {c=k;}
    
   //构造函数顺序：a,b,c

八、

虚函数是用virtual 关键字说明的成员函数。√
虚函数的作用：实现多态
虚函数必须是类的成员函数，不能是类的静态成员
派生类中对继承自基类的虚函数会进行重载已实现多态。 x
通过基类的指针删除派生对象时，通常情况下只调用基类的析构函数。但是，删除一个派生类的对象时应该先调派生类析构函数，然后调用基类的析构函数。解决办法：把基类的析构函数声明为虚析构函数。
类的构造函数可以定义为虚函数。 x
将构造函数说明为纯虚函数是没有意义的。
在一个成员函数内调用一个虚函数时，对该虚函数的调用进行动态束定。
如果派生类的成员函数的原型与基类中被定义为虚函数的成员函数原型相同，那么，这个函数自动继承基类中虚函数的特性。 √
重定义虚函数的派生类必须是公有继承的。
对于从基类继承的虚函数，派生类也可以不进行重定义。
派生类中的虚函数，不仅可以覆盖基类的虚函数，还会隐藏基类中同名函数的所有其它重载形式。
关于动态绑定的下列描述中，（）是错误的。 d

A.动态绑定是以虚函数为基础的

B.动态绑定在运行时确定所调用的函数代码

C.动态绑定调用函数操作是通过指向对象的指针或对象引用来实现的

D.动态绑定是在编译时确定操作函数的
虚成员函数应在类内定义声明，且必须有定义（实现）。在类外定义实现虚成员函数时，不能再加 virtual 关键字。纯虚函数的定义必须实现在类外定义。类外定义也是不需要加virtual关键字的
虚函数既可以在函数说明时定义，也可以在函数实现时定义。 x
派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型，必须都相同
在基类中将show声明为不带返回值的纯虚函数。virtual void show()=0;
纯虚函数是一种特殊的虚函数，它没有具体的实现。包含纯虚函数的类叫抽象类。抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出。抽象类的特性：不能定义该类对象
虚析构函数的作用是。 delete动态对象时释放资源
不能创建对象，但可以有指针或引用

class A {
public:
   A() { }
   virtual void func(){ cout << "A::func" << endl; }
   virtual void fund(){ cout << "A::fund" << endl; }
   void fun(){ cout << "A::fun" << endl;}
};
class B:public A {
public:
   B () { func() ; }
   void fun() { func() ; }
};
class C : public B {
public :
    C() { }
    void func(){cout << "C::func" << endl; }
    void fund(){ cout << "C::fund" << endl;}
};
int main()
{
A * pa = new B();
pa->fun();
B * pb = new C();
pb->fun();
return 0;
}

九、运算符重载

对单目运算符重载为友元函数时，可以说明一个形参。而重载为成员函数时，不能显式说明形参。
c++中不能重载的运算符有5个：“?:”、“.”、“::”、“sizeof”、“.*”
重载为成员函数时，参数个数为运算符数目减一。重载为友元函数时，参数个数为运算符数目。
()、[]、->、=只能重载为成员函数。
运算符重载不可以改变语法结构，不可以改变操作数个数等，不可以创造新的运算符，不改变优先级和结合性
重载的"[]"运算符应定义为：A& operator [ ] (int);
运算符被多次重载时,根据实参的类型（不是函数类型）决定调用哪个运算符重载函数
如何区分自增运算符重载的前置形式和后置形式？后置形式比前置形式多一个 int 类型的参数 后置++函数实现时内部先定义一个类对象然后返回类对象，前置++直接在原对象上操作
从运行的角度多态可分：编译时多态和运行时多态
运算符重载函数的两种主要方式是：成员函数和友元函数
强制类型转换是通过【强制类型转换运算符】来实现的。

istream &operator >>(istream & is ,Student &s ){
is>> s.name>>s.score;
return is;
}
ostream &operator <<(ostream & os ,Student &s){
static int sum;sum=sum+1;
os<<sum<<". "<<s.name<<" ";
return os;
}

十、函数模板、类模板

模板函数的真正代码是在哪个时期产生的。源程序中调用函数时
类模板的成员函数都是模板函数x
类模板只能有虚拟参数类型。用模板定义一个对象时，不能省略参数
创建pair<>对象只能调用其构造函数。x
类模板的成员函数被调用后才实现实例化
```
template <class T>
T*  
```

复习

原因为其基类 Base2 构造函数需要参数，因此必须在其构造函数的初始化列表中为 Base2 的构造函数传递参数以初始化继承自基类的成员。
虚基类只初始化一次，虚基类由最终派生类初始化
A* pa=new A(5) 创建A类的一个对象；A【5】是5个对象；new的空间不会自动释放一定要delete
虚析构：析构更彻底，会调用派生类的析构
静态成员函数可以是多个
int & fun（int &a）//a必须是变量，fun可以作为左值
异常：if(){throw error0;} ;try{} catch(){switch: case error1: break;}
A=65,a=97
a=5; b=++a; // 相当于a=a+1;b=a; 结果是a=6，b=6 a=5; b=a++; // 相当于b=a;a=a+1; 结果是a=6，b=5
顺序：有虚基类先构造虚基类，已经被构造过的就不用再构造了

yuitsu

关注

1
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
c++复习

在派生类D中，派生一个公有函数成员add（原型：int add (int x, int y, int z);Student1(int n,string nam,int a,string ad):Student(n,nam),monitor(n1,nam1) //派生类构造函数**结果是a=6，b=6 a=5;√ 即派生类无法直接访问基类的私有成员，但可以调用基类的函数访问私有成员。如果派生类的成员函数的原型与基类中被定义为虚函数的成员函数原型相同，那么，这个函数自动继承基类中虚函数的特性。
复制链接

扫一扫