C++笔试

最新推荐文章于 2022-06-03 11:49:03 发布
最新推荐文章于 2022-06-03 11:49:03 发布
阅读量474 收藏 3
点赞数
分类专栏： 笔试题 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianya_team/article/details/50890539
版权
1.交换字符串 
void SwapString(char *&x,char *&y)
{
	char *temp=x;
	x=y;
	y=temp;
}
调用方式： 
SwapString(a,b);

char *&x表示指针的引用，即char *表示字符串，&表示按引用传值。

或者

void SwapString(char **x,char **y)
{
	char *temp=*x;
	*x=*y;
	*y=temp;
}
调用方式： 
SwapString(&a,&b);


3.指针加减操作 
#include <iostream>
using namespace std;


int main()
{
	int a[5]={1,2,3,4,5};
	int *ptr=(int *)(&a+1);
	cout<<*(a+1)<<endl;
	cout<<*(ptr-1)<<endl;
	return 0;
}

输出：2 5


4.指针比较 
#include <iostream>
using namespace std;


int main()
{
	char str1[]="abc";   //str1在栈取
	char str2[]="abc";   //str2在栈区，但是str1与str2在栈区不同位置，不相等
	const char str3[]="abc";  //str3在栈区
	const char str4[]="abc";  //str4在栈区，但是str3与str4在栈区不同位置，不相等
	const char *str5="abc";    //"abc"在文字常量区，str5是"abc"的地址
	const char *str6="abc";    //str6也是"abc"的地址，和str5相等
	char *str7="abc";    //str7也是"abc"的地址
	char *str8="abc";    //str8也是"abc"的地址
	cout<<(str1==str2)<<endl;  //0
	cout<<(str3==str4)<<endl;  //0
	cout<<(str5==str6)<<endl;  //1
	cout<<(str6==str7)<<endl;  //1
	cout<<(str7==str8)<<endl;  //1
	return 0;
}


5.构造函数调用虚函数

#include<iostream>
#include <vector>
#include <assert.h>
#include <string>
using namespace std;


class Base{
public:
	Base(){ doSth(); }   //构造函数调用虚函数
	virtual void doSth(){
		cout << "I am Base" << endl;
	}
};

class Derived :public Base{
public:
	virtual void doSth(){
		cout << "I am Derived" << endl;
	}
};

int main(void)
{
	Derived d; //输出：I am Base
	return(0);
}
基类的构造函数在派生类构造函数之前执行，当基类构造函数运行时，派生类数据成员还没有被初始化。在构造函数中，虚函数机制不会发生作用。


6.如果继承类调用基类的非virtual函数，而该函数里面调用virtual函数，则在调用该virtual函数时，依然会出现多态。

#include<iostream>
#include <vector>
#include <assert.h>
#include <string>
using namespace std;


class Base{
public:
	Base(){}   //构造函数调用虚函数
	void f(){ doSth(); }
	virtual void doSth(){
		cout << "I am Base" << endl;
	}
};

class Derived :public Base{
public:
	virtual void doSth(){
		cout << "I am Derived" << endl;
	}
};

int main(void)
{
	Base *b=new Derived; 
	b->f();   //输出：I am Derived
	return(0);
}

7.多重继承构造顺序 

class Parent{
public:
	Parent(int n) :num(n){ cout << num << " Parent(int)" << endl; }
private:
	int num;
};

class Child1 :virtual public Parent{
public:
	Child1(int num) :Parent(num){ cout << num << "Child1(int)" << endl; }
};

class Child2 :virtual public Parent{
public:
	Child2(int num) :Parent(num){ cout << num << "Child2(int)" << endl; }
};

class Derived :public Child1, public Child2{
public:
	Derived(int num) :Child1(num), Child2(num + 1){}  //错误：Parent没有默认构造函数（Parent的初始化是按照Derived调用的构造函数来的）
};

8.构造函数调用另一个构造函数

#include<iostream>  
#include <vector>  
#include <assert.h>  
#include <string>  
using namespace std;  
  
  
struct CLS{  
    int m_i;  
    CLS(int i) :m_i(i){  
        cout << "CLS(int):this =" << this << endl;  
    }  
    CLS()  
    {  
        CLS(0);  //生成一个临时对象，对调用该函数的对象本身没影响  
        cout << "CLS():this =" << this << endl;  
    }  
};  
int main(void)  
{  
    CLS obj;  
    cout << "&obj=" << &obj << endl;  
    cout << obj.m_i << endl;  
    return(0);  
}

9.父类没有默认构造函数时，子类需要显式调用父类构造函数。

#include <iostream> 
#include <string>
using namespace std;

class Person{
private:
	string name;
public:
	Person(string nm){
		name = nm;
	}
};

class Employee :public Person{
	string empID;
public:
	Employee(string id){
		empID = id;
	}
	string GetEmpId(){ return empID; }
};

int main()
{
	Employee *e = new Employee("123");
	cout << e->GetEmpId() << endl;
	return 0;
}

这段代码会编译错误，修改如下：

#include <iostream> 
#include <string>
using namespace std;

class Person{
private:
	string name;
public:
	Person(string nm){
		name = nm;
	}
};

class Employee :public Person{
	string empID;
public:
	Employee(string id):Person("No name"){ //显式调用
		empID = id;
	}
	string GetEmpId(){ return empID; }
};

int main()
{
	Employee *e = new Employee("123");
	cout << e->GetEmpId() << endl;
	return 0;
}


10.在析构函数里面delete this指针.

如果一个类的析构函数如下：

class MyClass{
public:
	~MyClass(){
		delete this;
		this = NULL;
	}
};
则会出现编译错误，因为this指针本身是const不允许进行修改。

如果去掉对this赋值这句，则会导致栈溢出。因为delete的过程实际是先调用析构函数，然后释放内存，在析构函数里调用delete会导致递归调用，从而导致栈溢出。
如果在一般成员函数中删除this指针会出现什么情况？

#include <iostream> 
#include <string>
using namespace std;

class MyClass{
public:
	void Delete(){ cout << "Delete" << endl; delete this; }
	void Display(){ cout << "Display" << endl; }
	~MyClass(){
	}
};

int main()
{
	MyClass *my=new MyClass;
	my->Delete();
	my->Display();
	return 0;
}

在上面的例子中，可以正常的输出。

如果this对象不是new出来的呢？

#include <iostream> 
#include <string>
using namespace std;

class MyClass{
public:
	void Delete(){ cout << "Delete" << endl; delete this; }
	void Display(){ cout << "Display" << endl; }
	~MyClass(){
	}
};

int main()
{
	MyClass my;
	my.Delete();
	my.Display();
	return 0;
}
改程序在delete this:那句会崩溃，原因是this对象是在栈空间分配的，不能用delete来释放。
至于上面的例子，在delete this指针后，还能调用my->Display();原因是delete操作先调用析构函数，再调用delete运算符释放this指向的内存。delete之后不能再访问成员变量以及虚函数了。因为成员变量和vptr是存放在this指向的内存的。

11.关于char data[0]。

#include <iostream> 
#include <string>
using namespace std;

struct Node{
	int size;
	char data[0];
};

int main()
{
	char str[10] = "123456789";
	Node *n = (Node *)malloc(sizeof(Node) + strlen(str));
	memcpy(n->data, str, 10);
	cout << sizeof(Node) << endl;
	cout << n->data << endl;
	return 0;
}
编译器会认为data是一个长度为0的数组，而且会支持对data的跨界访问。

12.关于static局部变量

#include <iostream>
#include <string>
#include <vector>
using namespace std;


void func()
{
	static int i = 0;
	i++;
	cout << i << endl;
}

int main()
{
	func();
	func();
	func();
	return 0;
}
//输出：
//1
//2
//3


13.类对象指针指向NULL，仍可以通过该指针调用成员函数

#include<iostream>  
#include <vector>
#include <stack>
using namespace std;

class A{
public:
	void Test(){ cout << "Test" << endl; }
};

int main(){
	A *a = NULL;
	a->Test();
	return 0;
}
上面代码可以正常输出：Test

原因：

对于成员函数，并不是每个对象都拥有一份成员函数体而是所有的对象共用一份成员函数，程序编译之后，成员函数地址就已经确定。

而成员函数之所以能把属于此类的各个对象的数据区别开，就是靠这个this指针。函数体内所有对类数据成员的访问，都会被转化为this->数据成员的方式。

注意：静态成员函数也可以这样调用。

14.const修饰指针和指针所指对象

const在*号之前，修饰的是指针所指的对象，如const int * p，表示p所指的对象是常量，等价于int const * p。

const在*号之后，修饰的是指针本身，如int * const p，表示p表示的地址是常量，一般定义的时候要初始化。



15.函数指针和数组指针、指针数组

int *p[3]：指针数组，数组的每一个元素都是一个int型指针。

int (*p)[3]：数组指针，指针指向一个拥有3个int型数据的数组。

int (**p)[3]：是一个二级指针，指向的是一个一位数组的指针。（指向指针的指针）

int *(*p)[3]：数组指针，指向一个拥有3个int *类型数据的数组。

int (*p[3])()：p是一个数组，数组有3个元素，元素都是指向函数的指针，指向的函数是没有参数且返回int的函数。

int *((*p)[10])：和nt *(*p)[3]一样

int (*p)(int)：p是指针，指向一个函数，函数的参数是int型且返回int型。

int (*(*p)(int,int))(int)：p是一个函数指针，指向的函数有两个int参数并且返回一个函数指针，返回的函数指针指向有一个int参数且返回int的函数。

int (*(*p)[3])(int *)：p是数组指针，指向一个拥有3个元素的数组，每个元素都是一个函数指针，指向的函数参数是int *,返回类型是int。



16.在类的成员函数中调用delete this

myClass::foo(){
	delete this;
}
..
void func(){
	myClass *a = new myClass();
	a->foo();
}
在delete this之后的其他任何函数调用，只要不涉及this指针涉及的内容（数据成员和虚函数表指针），都能正常运行。所以这段代码没有问题。

注意：在析构函数中调用delete this，会导致堆栈溢出。因为delete的本质是为将要释放的内存调用一个或多个析构函数。delete this会调用本对象的析构函数，最终造成无线循环。

注意：this指针类型是 MyClass *const this，不能进行修改，如果在delete this后面加上this=NULL,则会导致编译不通过。


17.关于抽象类

1）抽象类只能用作其他类的基类，不能定义抽象类的对象。

2）抽象类不能用于参数类型、函数返回值或显示转换的类型

3）抽象类可以定义抽象类的指针和引用，此指针可以指向它的派生类，进而实现多态性。


18.关于多态

多态性包括两种：第一种是静态多态，通过函数重载和类模板实现；

第二种是动态多态，通过继承中的多态实现。


19.不能被重载的运算符

?:    ::     .    .*    sizeof    typeid       static_cast       dynamic_cast       interpret_cast


20.vector的两种访问方法

1）vector::at()：进行边界检查，如果访问超过了vector的范围，将抛出一个例外。v.at(i)

2）vector::operator[]：不进行边界检查，与C进行兼容。


21.STL一级容器：指容器元素本身是基本类型，非组合类型，有vector, list, deque。


22.关于几种排序

不稳定排序：选快希堆不稳

与初始顺序无关（时间复杂度不变）：对归选基不变



23.在重载一个运算符为成员函数时，其参数表中没有任何参数，说明该运算符是前缀一元运算符。

后缀一元运算符会加一个int参数，用来区分前后缀。



24.通过指针改变const修饰的变量

#include <iostream> 
using namespace std; 
int main(void) 
{ 
    const int a = 10; 
    int * p = (int *)(&a); 
    *p = 20; 
    cout<<"a = "<<a<<", *p = "<<*p<<endl; 
    return 0; 
}
输出：a = 10, *p = 20
原因是编译器在优化的过程中，会把const全部以内容替换掉，所以上面用10来替换掉a，而打印那个内存单元的地址对应的值就变成了20。


25.关于类的大小

struct A{
	A() {}
	~A() {}
	int m1;
	int m2;
};
struct B :A{
	B() {}
	~B() {}
	int m1;
	char m2;
	static char m3;
};
struct C{
	C() {}
	virtual~C() {}
	int m1;
	short m2;
};
类的大小只与成员变量（非static数据成员变量）和虚函数指针有关，还要考虑到对齐。

sizeof(A)=8字节

sizeof(B)=16字节（在类A的8个字节基础上再加上B自己的8字节）

sizeof(C)=12字节


26.构造和析构顺序

#include <iostream>
using namespace std;

class A
{
public:
	A()  { cout << "create A" << endl; }
	A(const A& other){ cout << "copy A" << endl; } //复制构造函数
	~A() { cout << "~A" << endl; }
};

class B :public A
{
public:
	B(A &a) :_a(a)
	{
		cout << "create B" << endl;
	}
	~B()
	{
		cout << "~B" << endl;
	}
private:
	A _a;
};

int main(void)
{
	A a;       //很简单，定义a的时候调用了一次构造函数  
	B b(a);
}
程序输出为：

create A（对应A a;）

create A（注意：创建b时先调用基类的默认构造函数，并不是对应_a的构造函数。）

copy A（对应A _a;但是使用的是拷贝构造函数，需要注意）

create B（然后才是执行B的构造函数内容）

~B（最后构造的最先析构）

~A

~A

~A


27.函数参数入栈顺序

#include <iostream>
using namespace std;

void func(const int& v1, const int& v2)
{
	std::cout << v1 << ' ';
	std::cout << v2 << ' ';
}

int main(int argc, char* argv[])
{
	int i = 0;
	func(++i, i++);
	return 0;
}
C函数参数入栈顺序为从右到左，刚开始i=0，右边参数先入栈，即v2对应i++的值，为0，此时i=1，然后左边参数入栈，即v1对应++i的值，为2.

所以程序输出：2 0


28.虚函数内联

虚函数不可以是内联的，内联的意思是“在编译期间将调用之处用被调函数来代替”，如果编译器还不知道哪个函数将被调用，便会拒绝生成内联调用。


29.虚函数和静态函数函数名和参数都一样是不允许的，实例调用的时候不知道调用哪个。


30.关于int *p = new int[10]()

对于内置类型而言，new仅仅是分配内存，不进行初始化，除非后面显示加()，相当于调用它的构造函数，对于自定义类型而言，只要一调用new，那么编译器不仅仅给它分配内存，还调用它的默认构造函数初始化，即使后面没有加()。


31.

#include <iostream>

using namespace std;

void func(void **p){
	p = (void **)1024UL;
}

void func2(void **p){
	*p = (void *)1024UL;
}

int main()
{
	void *p = NULL;
	func(&p);
	printf("%p\n", p);
	func2(&p);
	printf("%p\n", p);
	return 0;
}
//输出：
//00000000
//00000400


tianya_team
关注
专栏目录
西门子社招软件C/C++笔试题及答案
08-15
西门子社招软件C/C++笔试题及答案
指针作为函数参数
shiyu16的博客
10-10 1971
临近毕业，还有找工作的事情，繁忙之际还是坚持看一下C语言的知识，重点的地方或者不清楚的地方还是要记录一下。 本章以指针作为函数传参来说一下学习心得，大部分内容源自C语言程序设计课本。首先从C语言中函数参数的传递方向说起，大家都知道，C语言中函数参数的传递方向是单向的，只能由主调函数的实参传递到被调函数的形参，而形参的值不能传递给实参。但是依据传送的内容可以将函数参数分为值型参数和指针型参数。通常来
单词逆序（c/c++语言实现）
欢迎来到我的空间
03-25 3961
c语言实现单词逆序输出。如："I am from shanghai"输出: "shanghai from am i"#include &lt;stdio.h&gt; #include &lt;string.h&gt; void swap(char* head, char* tail);//实现字符串逆序 int main() { char str[] = "I am from shangha...
【基础题】【指针】Swap
清风微醺的博客
12-06 253
1.将两个字符数组交换 #include<iostream> #include<string.h> using namespace std; void swap(char *p1,char *p2){ char *temp = new char[10]; strcpy(temp,p1); strcpy(p1,p2); strcpy(p2,temp); } int main(){ char c1[10] = "Chian",c2[10] = "Korea"; cout&lt
C++新特性学习(2)
Christ的博客
07-28 804
1        通用性方面 1.1      继承构造函数 C++98: 不支持            派生类可以自动获得基类的成员和接口(虚函数和纯虚函数)，但非虚函数就无法派生使用，这包括构造函数。在构造派生类时，需要在初始化列表中显式调用基类的构造函数，以此完成派生类的构造。                 存在一种特例：基类A实现了多种构造函数以及其它成员，派生类B继承自A，B中
c++填空题
bless_my_head的博客
07-10 7380
5-1 阅读下面的程序，完成其中复制构造函数的代码。 #include <iostream> using namespace std; class CAT { public: CAT(); CAT(const CAT&); ~CAT(); int GetAge() const { return *itsAge; } void SetAge(int age){ *itsAg
C++笔试题附带答案
04-28
### C++笔试题知识点解析 #### 1. 类与对象的概念 - **概念解析**： - **类**：在面向对象编程中，类是一种抽象数据类型，它封装了一组属性（即数据成员）和一组行为（即成员函数）。类是对象的模板，用于定义一组...
C++笔试.zip_C++_C++笔试题
07-15
以下是一些C++笔试中可能会涉及到的重要知识点： 1. **基本语法**：包括变量声明、数据类型（如int, float, double, char）、运算符（算术、比较、逻辑、位操作）、流程控制（if-else, switch, for, while循环）。 ...
C++笔试题汇总（含答案与分析）
11-22
这是本人亲自总结的C++笔试题汇总，参考了网络很多C++笔试题（包括各大IT公司，游戏公司），挑选出了一些经典的题和难题做解析。 作用：对工作面试笔试和C++水平提高很有用处 内容：C++，STL等；
C++笔试题-面试.zip
06-02
在准备C++笔试和面试的过程中，了解和掌握关键知识点至关重要。C++作为一门强大的系统级编程语言，其面试和笔试通常会涵盖语法、数据结构、算法、内存管理、多线程等多个方面。以下是对这些核心领域的详细阐述： 1....
一道C++的笔试题
wuxinliulei的专栏
10-01 1184
http://our2848884.blog.163.com/blog/static/146854834201182711236859/?suggestedreading&wumii 今天看到一道C++的笔试题，感觉不错！记录一下。 char str1[] = "abc"; char str2[] = "abc"; const char str3[] = "ab
每日一题（37）—— 常量存储区
血染风采2019
08-18 592
char str1[] = "abc"; char str2[] = "abc"; const char str3[] = "abc"; const char str4[] = "abc"; const char *str5 = "abc"; const char *str6 = "abc"; char *str7 = "abc"; char *str8 = "abc"; cout <<
第五周 课后实践：阅读程序（4）（5）（6）
Timor7hao的专栏
04-06 389
（4）问题及代码： /* * Copyright (c) 2014, 烟台大学计算机学院 * All rights reserved. * 文件名称：Project4.cpp * 作 者：陈旭 * 完成日期：2015年4月 7日 * 版 本 号：v1.0 * * 问题描述：阅读程序，写出程序的运行结果并理解 * 输入描述：略 * 程序输出：略 */ #inclu
C++ sizeof
mokorea的博客
06-10 514
空类型的实例不包含任何信息，但声明为实例时，对该类型求sizeof，得到的结果为1。原因在于，声明该实例时，必须占用一定的内存空间。至于空间占用多少内存，由编译器决定 class MyClass { public: //MyClass(); //~MyClass(); private: }; int main() { MyClass me; cout << sizeo...
【c++友元】
weixin_64166314的博客
06-03 148
C++友元函数
C++类静态成员与类静态成员函数
ruby_doudou的博客
08-25 289
静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数； 非静态成员函数可以任意地访问静态成员函数和静态数据成员； 静态成员函数访问非静态成员函数和非静态数据成员的方式---静态函数成员必须通过对象名来访问非静态数据成员。言下之意，我们可以通过传入this指针（或一个对象名）的方式访问非静态成员，又或者在静态成员函数内new一个对象，通过其调用非静态成员
探讨一下（i++）语意 不是什么先++ 后++
u012516571的博客
09-16 242
作者：弯弯的丝瓜 函数func的定义如下： 1 2 3 4 5 voidfunc(constint&amp; v1,constint&amp; v2) {    std::cout &lt;&lt; v1 &lt;&lt;' ';    std::cout &lt;&lt; v2 &lt;&lt;' '; ...
关于无符号数的减法为负值
热门推荐
tianya_team
02-22 1万+
#include using namespace std; int main() { unsigned int u1 = 42, u2 = 10; cout << u1 - u2 << endl; cout << u2 - u1 << endl; return 0; } 上面的输出结果为： 32 4294967264 显然下面的结果是-32与16位整数取模后的值。 这样理解：
求二范数C++代码
tianya_team
11-23 5429
#include #include using namespace std; #define NUM 3 float num[NUM][NUM] = { 1,2,3,4,5,6,7,8,9 }; void Loop(float a[NUM][NUM], float u[NUM], int n) { float S, U[NUM]; int i, j; for (int i = 0
华为C++笔试题解析及答案
“华为公司的C++笔试题目，包含解答，主要涉及C++语法、表达式求值、内存管理、预处理指令、类型兼容以及函数调用等知识点。” 本文将详细分析并解释华为C++笔试题中的关键知识点，帮助理解C++编程的基础和进阶概念...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值