个性化阅读
专注于IT技术分析

最新面试题!C++精品面试题合集推荐

C++面试题

下面列出了最常见的C ++面试问题和答案。

1)什么是C ++?

C ++是由Bjarne Stroustrup创建的一种面向对象的编程语言。它于1985年发布。

C ++是C的超集, 主要增加了C语言中的类。

最初, Stroustrup将新语言称为”带有类的C”。但是, 一段时间后, 名称更改为C ++。 C ++的思想来自C增量运算符++。


2)C ++有哪些优势?

C ++不仅维护了C语言的所有方面, 还简化了内存管理并添加了以下功能:

  • C ++是一种高度可移植的语言, 这意味着使用C ++语言开发的软件可以在任何平台上运行。
  • C ++是一种面向对象的编程语言, 其中包含诸如类, 对象, 继承, 多态性, 抽象之类的概念。
  • C ++具有继承的概念。通过继承, 可以消除冗余代码, 并可以重用现有的类。
  • 数据隐藏可以帮助程序员构建安全的程序, 以使程序不会受到入侵者的攻击。
  • 消息传递是一种用于对象之间通信的技术。
  • C ++包含丰富的函数库。

3)C和C ++有什么区别?

以下是C和C ++之间的区别:

C C++
C ++语言是由Bjarne Stroustrup开发的。
C ++支持结构化和面向对象的编程语言。
C ++是C的超集。
在C ++语言中, 数据和函数都以项目的形式封装在一起。
C ++支持数据隐藏。因此, 数据不能被外界访问。
C ++支持函数和运算符重载。
在C ++中, 该函数可以在结构内部实现。
C ++支持参考变量。
C ++同时支持虚拟和朋友功能。
C ++主要使用流cin和cout来执行输入和输出操作。

4)引用和指针有什么区别?

以下是引用和指针之间的区别:

Reference Pointer
指针是一个变量, 用于存储变量的地址。
指针变量需要一个间接运算符来访问变量的值。
指针变量是一个独立变量, 意味着可以重新分配它以指向不同的对象。
可以将空值分配给参考变量。
声明时不必初始化变量。

5)什么是课程?

该类是用户定义的数据类型。该类用关键字class声明。该类包含数据成员, 其成员函数由三个修饰符定义的成员函数是私有, 公共和受保护的。该类定义事物类别的类型定义。它定义了一个数据类型, 但没有定义数据, 仅指定了数据结构。

你可以从一个类中创建N个对象。


6)C ++中的各种OOP概念是什么?

C ++中的各种OOPS概念是:

C++面试题
  • 类:

该类是用户定义的数据类型, 用于定义其属性和功能。例如, 人类是一类。人的身体部位就是其属性, 身体部位所执行的动作称为功能。该类不占用任何内存空间。因此, 可以说该类是数据的唯一逻辑表示。

声明类的语法:

class student
{
//data members;
//Member functions
}
  • 宾语:

对象是运行时实体。对象是类的实例。一个对象可以代表一个人, 一个地方或任何其他项目。一个对象可以同时作用于数据成员和成员函数。该类不占用任何内存空间。使用new关键字创建对象时, 将为堆中的变量分配空间, 并且起始地址存储在堆栈存储器中。当创建没有新关键字的对象时, 则不会在堆内存中分配空间, 并且该对象在堆栈中包含空值。

class Student
{
//data members;
//Member functions
}

声明对象的语法:

Student s = new Student();
  • 遗产:

继承提供了可重用性。可重用性意味着可以使用现有类的功能。它消除了代码的冗余。继承是一种从旧类派生新类的技术。旧的类称为基类, 而新的类称为派生类。

语法

class derived_class :: visibility-mode base_class;

注意:可见性模式可以是公共, 私有, 受保护的。

  • 封装形式:

封装是一种将数据成员和成员函数包装在单个单元中的技术。它将数据绑定到一个类中, 并且没有外部方法可以访问该数据。如果数据成员是私有的, 则成员函数只能访问数据。

  • 抽象:

抽象是仅显示基本细节而不表示实现细节的技术。如果成员是用public关键字定义的, 则成员也可以在外部访问。如果成员是使用private关键字定义的, 则外部方法无法访问这些成员。

  • 数据绑定:

数据绑定是绑定应用程序UI和业务逻辑的过程。业务逻辑中的任何更改将直接反映到应用程序UI。

  • 多态性:

多态性是指多种形式。多态性是指具有相同名称但功能不同的多个功能。多态性有两种类型:

  1. 静态多态性也称为早期绑定。
  2. 动态多态性也称为后期绑定。

7)C ++中的多态性有哪些不同类型?

多态:多态是指多种形式。这意味着具有相同功能名称但功能不同的多个功能。

多态性有两种类型:

C++面试题
  • 运行时多态

运行时多态也称为动态多态。函数覆盖是运行时多态性的一个示例。函数覆盖意味着子类包含父类中已经存在的方法。因此, 子类将覆盖父类的方法。如果函数被覆盖, 则父类和子类都包含具有不同定义的相同函数。在运行时确定对函数的调用称为运行时多态。

让我们通过一个例子来理解这一点:

#include <iostream>
using namespace std;
class Base
{
    public:
    virtual void show()
    {
        cout<<"srcmini";
     }
};
class Derived:public Base
{
    public:
    void show()
    {
        cout<<"srcmini tutorial";
    }
};

int main()
{
    Base* b;
    Derived d;
    b=&d;
    b->show();
                return 0;
}

输出

srcmini tutorial
  • 编译时多态

编译时多态也称为静态多态。在编译时实现的多态被称为编译时多态。方法重载是编译时多态性的一个示例。

方法重载:方法重载是一种技术, 它使你可以拥有多个具有相同功能名称但功能不同的功能。

方法重载可能基于以下原因:

  • 重载函数的返回类型。
  • 传递给函数的参数类型。
  • 传递给函数的参数数量。

让我们通过一个例子来理解这一点:

#include <iostream>
using namespace std;
class Multiply
{
   public:
   int mul(int a, int b)
   {
       return(a*b);
   }
   int mul(int a, int b, int c)
   {
       return(a*b*c);
  }
 };
int main()
{
    Multiply multi;
    int res1, res2;
    res1=multi.mul(2, 3);
    res2=multi.mul(2, 3, 4);
    cout<<"\n";
    cout<<res1;
    cout<<"\n";
    cout<<res2;
    return 0;
}

输出

6
24
  • 在上面的示例中, mul()是具有不同数量参数的重载函数。

8)在C ++中定义名称空间。

  • 命名空间是代码的逻辑划分, 旨在停止命名冲突。
  • 命名空间定义了声明诸如变量, 类, 函数之类的标识符的范围。
  • 在C ++中使用名称空间的主要目的是消除歧义。当不同的任务以相同的名称发生时, 会发生歧义。
  • 例如:如果存在两个具有相同名称的函数, 例如add()。为了避免这种歧义, 使用了名称空间。函数在不同的名称空间中声明。
  • C ++包含一个标准命名空间, 即std, 其中包含内置的类和函数。因此, 通过使用语句” using namespace std;”在我们的程序中包括名称空间” std”。
  • 命名空间的语法:
namespace namespace_name
{
 //body of namespace;
}

访问名称空间变量的语法:

namespace_name::member_name;

让我们通过一个例子来理解这一点:

#include <iostream>
using namespace std;
namespace addition
{
    int a=5;
    int b=5;
    int add()
    {
        return(a+b);
    }
}

int main() {
int result;
result=addition::add();
cout<<result;
return 0;
}

输出

10

9)在C ++中定义令牌。

C ++中的令牌可以是关键字, 标识符, 文字, 常量和符号。


10)谁是C ++的创造者?

Bjarne Stroustrup。


11)指针可以进行​​哪些操作?

以下是可以对指针执行的操作:

  • 增加或减少指针:增加指针意味着我们可以将指针增加其指向的数据类型的大小。

增量指针有两种:

1.预递增指针:预递增运算符将操作数递增1, 表达式的值成为递增的结果值。假设ptr是一个指针, 则预递增指针表示为++ ptr。

让我们通过一个例子来理解这一点:

#include <iostream>
using namespace std;
int main()
{
int a[5]={1, 2, 3, 4, 5};
int *ptr;
ptr=&a[0];
cout<<"Value of *ptr is : "<<*ptr<<"\n";
cout<<"Value of *++ptr : "<<*++ptr;
return 0;
}

输出

Value of *ptr is : 1
Value of *++ptr : 2

2.后递增指针:后递增运算符将操作数递增1, 但是表达式的值将是操作数的值, 而不是操作数的递增值。假设ptr是一个指针, 则后递增指针表示为ptr ++。

让我们通过一个例子来理解这一点:

#include <iostream>
using namespace std;
int main()
{
int a[5]={1, 2, 3, 4, 5};
int *ptr;
ptr=&a[0];
cout<<"Value of *ptr is : "<<*ptr<<"\n";
cout<<"Value of *ptr++ : "<<*ptr++;
return 0;
}

输出

Value of *ptr is : 1
Value of *ptr++ : 1
  • 从另一个指针减去一个指针:当减去两个指向数组成员的指针时, 将返回两个成员之间存在的元素数。

12)定义” std”。

Std是C ++中使用的默认名称空间标准。


13)哪种编程语言的不令人满意的性能导致了C ++的发现?

发现C ++是为了应对C的缺点。


14)delete []与delete有何不同?

Delete用于释放一个内存单元, delete []用于释放数组。


15)C ++中STL的完整形式是什么?

STL代表标准模板库。


16)什么是物体?

对象是类的实例。一个类为对象提供了一个蓝图。因此, 你可以从类创建对象。类的对象的声明与我们声明基本类型的变量的声明相同。


17)什么是C ++访问说明符?

访问说明符用于定义如何在类外部访问函数和变量。

有三种类型的访问说明符:

  • 私有:声明为私有的函数和变量只能在同一类中访问, 而不能在声明的类之外访问。
  • Public:可以在任何地方访问在public下声明的函数和变量。
  • 受保护的:声明为受保护的函数和变量只能在子类之外的类之外访问。该说明符通常用于继承。

18)什么是面向对象编程(OOP)?

OOP是一种提供许多概念的方法论或范式。面向对象编程的基本概念如下:

类和对象:类用于指定数据的结构。它们定义数据类型。你可以从一个类中创建任意数量的对象。对象是类的实例。

封装:封装是一种将数据和关联的操作绑定在一起, 从而将数据隐藏在外部世界中的机制。封装也称为数据隐藏。在C ++中, 它是通过使用访问说明符(即公共, 私有和受保护的)来实现的。

抽象:抽象用于隐藏内部实现, 并仅向外部世界显示必要的细节。数据抽象是使用C ++中的接口和抽象类实现的。

有些人对封装和抽象感到​​困惑, 但是他们两者是不同的。

继承:继承用于将一个类的属性继承到另一个类。它可以帮助你用另一类来定义一个类。


19)数组和列表之间有什么区别?

  • 数组是同质元素的集合, 而列表是异质元素的集合。
  • 数组内存分配是静态且连续的, 而列表内存分配是动态且随机的。
  • 在Array中, 用户无需跟踪下一个内存分配, 而在列表中, 用户必须跟踪下一个分配内存的位置。

20)new()和malloc()有什么区别?

  • new()是预处理器, 而malloc()是函数。
  • 使用” new”时无需分配内存, 但是在malloc()中必须使用sizeof()。
  • ” new”将新内存初始化为0, 而malloc()在新分配的内存位置中给出随机值。
  • new()运算符分配内存并为对象初始化调用构造函数, 而malloc()函数分配内存, 但不为对象初始化调用构造函数。
  • new()运算符比malloc()函数快, 因为运算符比该函数快。

21)从DLL导出功能的方法有哪些?

有两种方法:

  • 通过使用DLL的类型库。
  • 从DLL实例中引用该函数。

22)定义朋友功能。

朋友功能充当班级的朋友。它可以访问该类的私有成员和受保护成员。朋友功能不是该类的成员, 但是必须在类定义中列出。非成员函数无法访问该类的私有数据。有时, 非成员函数必须访问数据。朋友功能是一个非成员功能, 可以访问该类的私有数据。

为了使外部函数对类友好, 我们需要将函数声明为类的朋友, 如下所示:

class sample
{
   // data members;
 public:
friend void abc(void);
};

以下是朋友功能的特征:

  • 朋友函数不在声明它的类的范围内。
  • 由于它不在类的范围内, 因此不能通过使用类的对象来调用它。因此, 可以像普通功能一样调用好友功能。
  • 朋友功能无法直接访问私有成员, 它必须在每个成员名称中使用对象名称和点运算符。
  • Friend函数使用对象作为参数。

让我们通过一个例子来理解这一点:

#include <iostream>
using namespace std;
class Addition
{
 int a=5;
 int b=6;
 public:
 friend int add(Addition a1)
 {
     return(a1.a+a1.b);
 }
};
int main()
{
int result;
Addition a1;
 result=add(a1);
 cout<<result;
return 0;
}

输出

11

23)什么是虚函数?

  • 虚拟函数用于替换基类提供的实现。只要有问题的对象实际上是派生类的, 就总是调用替换, 即使该对象是由基本指针而不是派生指针访问的。
  • 虚函数是存在于基类中并由派生类重新定义的成员函数。
  • 当我们在基类和派生类中使用相同的函数名称时, 基类中的函数用关键字virtual声明。
  • 将函数设为虚拟时, C ++会在运行时根据基类指针所指向的对象的类型来确定要调用哪个函数。因此, 通过使基类指针指向不同的对象, 我们可以执行不同版本的虚函数。

虚函数规则:

  • 虚函数应该是某个类的成员。
  • 虚函数不能是静态成员。
  • 通过使用对象指针来调用虚函数。
  • 它可以是另一个班级的朋友。
  • C ++不包含虚拟构造函数, 但可以具有虚拟析构函数。

24)什么时候应该使用多重继承?

你可以通过三种方式回答此问题:

  1. 决不
  2. 很少
  3. 如果发现问题域无法通过其他任何方式准确建模。

25)什么是析构函数?

析构函数用于删除对象分配的任何额外资源。对象超出范围后, 将自动调用析构函数。

破坏者规则:

  • 析构函数的名称与类名称相同, 并且以波浪号开头。
  • 它不包含任何参数, 也没有返回类型。

26)什么是溢出错误?

这是一种算术错误。当算术运算的结果大于系统提供的实际空间时, 就会发生这种情况。


27)什么是超载?

  • 当单个对象以多种方式运行时, 称为重载。单个对象具有相同的名称, 但是它提供相同功能的不同版本。
  • C ++可以帮助你为同一范围内的函数名或运算符指定多个定义。分别称为函数重载和运算符重载。
  • 重载有两种类型:
C++面试题

1.运算符重载:运算符重载是一种编译时多态性, 其中标准运算符被重载以为其提供用户定义的定义。例如, ‘+’运算符被重载以对int, float等数据类型执行加法运算。

运算符重载可以通过以下功能实现:

  • 会员功能
  • 非会员功能
  • 朋友功能

运算符重载的语法:

Return_type classname :: Operator Operator_symbol(argument_list)
{
      // body_statements;
}

2.函数重载:函数重载也是一种编译时多态性, 可以定义具有相同名称的一系列函数。该函数将根据函数调用中的参数列表执行不同的操作。要调用的函数取决于参数数量和参数列表中参数的类型。


28)什么是功能替代?

如果你将一个类继承到派生类中, 并在派生类中再次为基类的功能之一提供定义, 则此功能称为覆盖功能, 这种机制称为功能覆盖。


29)什么是虚拟继承?

使用虚拟继承, 即使对象在层次结构中出现多个, 你也可以仅为每个对象创建一个副本。


30)什么是构造函数?

构造函数是一种初始化对象的特殊方法。其名称必须与类名称相同。


31)”删除”运算符的目的是什么?

“删除”运算符用于释放”新”运算符创建的动态内存。


32)解释这个指针?

该指针保存当前对象的地址。


33)范围解析运算符做什么?

范围解析运算符(::)用于在类外部定义成员函数。


34)delete和delete []有什么区别?

Delete []用于释放使用new []分配的已分配内存的数组, 而delete用于释放使用new分配的一块内存。


35)什么是纯虚函数?

纯虚函数是不包含任何定义的虚函数。正常功能之前带有关键字virtual。纯虚函数以0结尾。

纯虚函数的语法:

virtual void abc()=0;   //pure virtual function.

让我们通过一个例子来理解这一点:

#include<iostream>
using namespace std;
class Base
{
    public:
    virtual void show()=0;
};

class Derived:public Base
{
    public:
    void show()
    {
        cout<<"srcmini";
    }
};
int main()
{
    Base* b;
    Derived d;
    b=&d;
    b->show();
    return 0;
}

输出

srcmini

36)struct和class有什么区别?

Structures class
该类是用户定义的数据类型, 其中包含成员变量和成员函数。
类的变量存储在堆内存中。
我们可以直接初始化成员变量。
如果未指定访问说明符, 则默认情况下, 变量的访问说明符为”专用”。
类的声明:class class_name {    //类的主体; }
通过使用class关键字声明该类。
该类支持继承的概念。
类的类型是引用类型。

37)什么是课程模板?

类模板用于创建一系列的类和函数。例如, 我们可以创建一个数组类的模板, 这将使我们能够创建各种类型的数组, 例如int, float, char等。类似地, 我们可以为一个函数创建一个模板, 假设我们有一个函数add (), 然后我们可以创建add()的多个版本。

类模板的语法:

template<class T>
class classname
{
  // body of class;
};

模板类对象的语法:

classname<type> objectname(arglist);

38)函数重载和运算符重载有什么区别?

函数重载:定义函数重载是因为我们可以拥有多个相同功能的版本。函数的版本将具有不同的签名, 这意味着它们具有不同的参数集。

运算符重载:定义运算符重载是因为可以重新定义标准运算符, 以便在应用于类的实例时具有不同的含义。


39)什么是虚拟析构函数?

在基类中使用C ++中的虚拟析构函数, 以便也可以销毁派生的类对象。通过使用〜波浪号运算符, 然后在构造函数之前使用virtual关键字, 可以声明虚拟析构函数。

注意:构造函数不能是虚拟的, 但是析构函数可以是虚拟的。

让我们通过一个例子来理解这一点

  • 不使用虚拟析构函数的示例
#include <iostream>
using namespace std;
class Base
{
    public:
    Base()
    {
        cout<<"Base constructor is called"<<"\n";
    }
    ~Base()
    {
        cout<<"Base class object is destroyed"<<"\n";
    }
};
class Derived:public Base
{
    public:
    Derived()
    {
        cout<<"Derived class constructor is called"<<"\n";
    }
    ~Derived()
    {
        cout<<"Derived class object is destroyed"<<"\n";
    }
};
int main() 
{
  Base* b= new Derived;
  delete b;
  return 0;
  
}

输出

Base constructor is called
Derived class constructor is called
Base class object is destroyed

在上面的示例中, delete b将仅调用基类析构函数, 这是因为派生类析构函数保持不变。这导致内存泄漏。

  • 虚拟析构函数示例
#include <iostream>
using namespace std;
class Base
{
    public:
    Base()
    {
        cout<<"Base constructor is called"<<"\n";
    }
    virtual ~Base()
    {
        cout<<"Base class object is destroyed"<<"\n";
    }
};
class Derived:public Base
{
    public:
    Derived()
    {
        cout<<"Derived class constructor is called"<<"\n";
    }
    ~Derived()
    {
        cout<<"Derived class object is destroyed"<<"\n";
    }
};
int main() 
{
  Base* b= new Derived;
  delete b;
  return 0;
  
}

输出

Base constructor is called
Derived class constructor is called
Derived class object is destroyed
Base class object is destroyed

当我们使用虚拟析构函数时, 首先调用派生类析构函数, 然后再调用基类析构函数。


Java OOP面试问题
Java字符串和异常问题
JDBC面试问题
JSP面试问题
休眠面试问题
SQL面试题
Android面试题
MySQL面试问题

C语言由Dennis Ritchie开发。

C是一种结构化的编程语言。

C是C ++的子集。

在C语言中, 数据和函数是自由实体。

C不支持数据隐藏。因此, 数据可以被外界使用。

C不支持函数也不支持运算符重载。

在C语言中, 该函数无法在结构内部实现。

C语言不支持参考变量。

C语言不支持虚拟和朋友功能。

在C语言中, scanf()和printf()主要用于输入/输出。

引用的行为类似于现有变量的别名, 即它是一个临时变量。

引用变量不需要任何间接运算符即可访问该值。引用变量可以直接用于访问值。

分配参考变量后, 便无法使用不同的地址值对其进行重新分配。

无法将空值分配给参考变量。

在声明时必须初始化变量。

结构是用户定义的数据类型, 其中包含不同数据类型的变量。

结构的变量存储在堆栈存储器中。

我们不能直接初始化变量。

如果未指定访问说明符, 则默认情况下, 变量的访问说明符为” public”。

结构的实例是”结构变量”。

结构的声明:

struct structure_name
{
   // body of structure;
} ;

通过使用struct关键字声明结构。

该结构不支持继承。

结构的类型是值类型。

Java基础面试问题

Java多线程问题

Java Collection面试题

Servlet面试问题

春季面试问题

PL / SQL面试问题

Oracle面试问题

SQL Server面试问题

赞(0) 打赏
未经允许不得转载:srcmini » 最新面试题!C++精品面试题合集推荐
分享到: 更多 (0)

评论 抢沙发

评论前必须登录!

 

觉得文章有用就打赏一下文章作者

微信扫一扫打赏