918c++ 易混淆的选填题

推荐一个在线编程c++的网址：c++

建议观看这个视频：100道c++题目讲解

如果时间充足且看完上面那个视频可以看看这个：c++题目进阶


常量字符串必须初始化

函数会一一对应按顺序解析参数第二个参数不能是字符串只能是int类型

在C++程序中，如果我没没有对函数的类型进行说明的话，那么函数的默认类型是int类型的，也就是说函数必须返回一个int型的返回值。

常成员函数需要在声明和定义的时候在函数头部的结尾加上 const 关键字

c++与Java不同，未定义的类为private

为什么静态成员函数只能访问静态成员变量。

答：1.静态成员函数只属于类本身，随着类的加载而存在，不属于任何对象，是独立存在的

2.非静态成员当且仅当实例化对象之后才存在，静态成员函数产生在前，非静态成员函数产生在后，故不能访问

3.内部访问静态成员用self：：，而访问非静态成员要用this指针，静态成员函数没有this指针，故不能访问。


第一题：a[3]调用3次，p是类指针。
类指针要分配了动态空间才调用构造函数的
第二题：a，b各一次，c调用3次，p是类指针。

动态联编需要满足三个条件:
1 类之间满足兼容赋值规则
2 声明虚函数
3 使用类的指针或者引用访问虚函数或者通过成员函数调用虚函数




单目运算符：只对一个变量进行操作。EX：a++；
双目运算符：对两个变量进行操作；EX：a=1; b=3; c=a+b;就是双目运算符；
三目运算符，又称条件运算符，也叫多目运算符：EX： b = (a > c) ? a : c;

关于静态和动态联编的博客：[https://blog.csdn.net/gaoxin1076/article/details/8298279]



c++这点与Java不同，Java只允许单继承也就是每个类只有一个父类，c++可以多继承

请讲一下析构函数与虚函数的作用和用法，是否存在虚析构函数
讲解视频：讲解

是否存在虚构造函数
答：不存在

这题考的是指针的使用，不理解的要重新研读指针的概念
A：&j表示j的地址，所以相当于拿i的值和j的地址比
B：如果单是p的话表示i的地址，但是*p表示的是i的值，所以相当于拿i的值和i的值比
C：上面说了*p相当于i的值，&j相当于j的地址，但是*一个地址相当于这个地址的值，所以相当于那i的值和j的值比
D：没有声明**p。

从语义角度上来说，protected继承是一种实现继承

从语法角度上来说，protected继承后，父类public和protected成员都变成子类的protected成员了

对于类中不能初始化变量的个人理解：

类的定义实际相当与类型声明，并没有分配存储空间，初始化的数据哪里放? 类实例化以后才会有实体存储地址及空间。

静态成员函数只能访问静态成员变量->静态成员函数没有this指针

解决多重继承二义性有三种办法分别是作用域分辨操作符，虚基类和同名覆盖。具体看开这篇博客 C++多重继承二义性解决

赋值兼容规则
对于公有派生来说，可以将派生类的对象赋给基类的对象，反之是不可以的。
赋值兼容性规则可以总结为4点:
1、不允许将基类的对象赋给派生类的对象。
2、派生类的对象可以赋给基类的对象。
3、可将派生类的对象的指针赋给基类的指针变量。
4、派生类对象可以初始化基类型的引用。

我觉得这题出的不好AB都可以，但是答案是A所以就贴出来。

程序阅读题：

#include <iostream>					// 预处理命令
using namespace std;					// 使用标准命名空间std

class MyClass
{
public:
	MyClass(){ count++; }
	~MyClass(){	count--; }
	static int GetCount(){ return count; }

private:
	static int count;
};

int MyClass::count = 0;				// 初始化静态数据成员

int main(void)
{
	MyClass obj1;
	cout << MyClass::GetCount() << endl;
	MyClass obj2;
	cout << MyClass::GetCount() << endl;
	MyClass obj3;
	cout << obj1.GetCount() << endl;
	MyClass *p = new MyClass;
	cout << MyClass::GetCount() << endl;
	delete p;
	cout << MyClass::GetCount() << endl;

	return 0;                    		// 返回值0, 返回操作系统
}

上面程序的输出结果为：

1
2
3
4
3

//需要注意MyClass::GetCount()这样调用方法只触发构造函数不会触发析构函数

程序阅读题：

#include <iostream>					// 预处理命令
using namespace std;					// 使用标准命名空间std

class A
{
public:
	A() { cout << "A()" << endl; }
	~A() { cout << "~A()" << endl; }
	virtual void f() { cout << "A::f()" << endl; }
};

class B: public A
{
public:
	B() { cout << "B()" << endl; }
	~B() { cout << "~B()" << endl; }
	void f() { cout << "B::f()" << endl; }	
};

int main(void)					
{
	B obj;				
	A *p = &obj;				
	p->f();				

	return 0;                    		// 返回值0, 返回操作系统
}

上面程序的输出结果为：

A()
B()
B::f()
~B()
~A()

需要注意：
1.析构函数先调用派生类，后调用基类
2.构造函数调用优先级：基类构造函数总是被优先调用，这说明创建派生类对象时，会先调用基类构造函数，再调用派生类构造函数。

![

派生类对基类成员的三种访问规则：

1、私有继承的访问规则

当类的继承方式为私有继承时，基类的public成员和protected成员被继承后成为派生类的private成员，派生类的其它成员可以直接访问它们，但是在类的外部通过派生类的对象无法访问。

基类的private成员在私有派生类中是不可直接访问的，所以无论是派生类的成员还是通过派生类的对象，都无法直接访问从基类继承来的private成员，但是可以通过基类提供的public成员函数间接访问。

2、公有继承的访问规则

当类的继承方式为公有继承时，基类的public成员和protected成员被继承到派生类中仍作为派生类的public成员和protected成员，派生类的其它成员可以直接访问它们。但是，类的外部使用者只能通过派生类的对象访问继承来的public成员。

基类的private成员在私有派生类中是不可直接访问的，所以无论是派生类成员还是派生类的对象，都无法直接访问从基类继承来的private成员，但是可以通过基类提供的public成员函数直接访问它们。

3、保护继承的访问规则

当类的继承方式为保护继承时，基类的public成员和protected成员被继承到派生类中都作为派生类的protected成员，派生类的其它成员可以直接访问它们，但是类的外部使用者不能通过派生类的对象访问它们。

基类的private成员在私有派生类中是不可直接访问的，所以无论是派生类成员还是通过派生类的对象，都无法直接访问基类中的private成员。

一元运算符有1个操作数。例如，递增运算符"++“就是一元运算符，二元运算符有2个操作数。例如，除法运算符”/"有2个操作数。

程序输出题：

void fun(int &x, int y)
{ int t=x; x=y; y=t; }
int main( )
{ int a[2] = {23, 42};
  fun(a[1],a[0]);
  std::cout<<a[0]<<","<<a[1]<<std::endl;
  return 0; }

23，23

A:定义

&&（与） ||（或）

c：在类中定义的函数一般默认是inline的

这题选A
C++ 拷贝构造函数在哪几种情况下会被调用？

当类的一个对象去初始化该类的另一个对象时；
如果函数的形参是类的对象，调用函数进行形参和实参结合时；
如果函数的返回值是类对象，函数调用完成返回时。

使用运算符对数据进行格式输出时，必须要包含iomanip.h头文件。