面试题_ue4堆和栈的区别

4.下面关于“联合”的题目的输出？
题目1：

union
{
　　int i;
　　char x[2];
}a;

a.x[0] =10;
a.x[1] =1;
printf("%d",a.i);

 答案：266 (低位低地址，高位高地址，内存占用情况是Ox010A）

解答：union是共享内存的数据类型，其内存大小以union中size最大的为准，这里是4个字节（在32位机子中，int占4个字节，而char占1个字节，x就占2个字节）。内存占用情况是：0x010A，因为低位低地址，高位高地址，组合起来就是了（为什么a.x[0]是0A？因为char占1个字节，用16进制表示就是2位）。当使用
printf打印a.i的值时，尽管这里没有对a.i赋值，但是由于是union类型，它们都占用相同的内存，所以a.i是有值的，取法就是：从低位开始，根据a.i占用的字节大小截断取值。这里a.i占用4个字节，而a.x却是2个字节，所以就全部取走，即a.i的值为0x010A。如果我们将char x[2]改为char x[5]，如下：

union
{
    int i;
    char x[5];
}a;

a.x[0] = 0x00;
a.x[1] = 0x01;
a.x[2] = 0x02;
a.x[3] = 0x03;
a.x[4] = 0x04;

cout << a.i << endl;
cout << 0x03020100 << endl;    // a.i的值
cout << 0x0403020100 << endl; //当前a的内存占用情况

 此时a.i就只会截取前面4个字节的值，即0x03020100，而不是全部的内存中的值0x0403020100。

关于union一些高级的用法可以看看这篇文章：c++中union的使用，看高手们如何解释的

 题目2：

union
{ 
    int i; 
    struct
    {
        char first; 
        char second; 
    }half; 
}number; 

number.i=0x4241; /*联合成员赋值*/ 
printf("%c%c\n", number.half.first, number.half.second); 
number.half.first='a'; /*联合中结构成员赋值*/ 
number.half.second='b'; 
printf("%x\n",number.i); 

 答案： AB (0x41对应'A',是低位；Ox42对应'B',是高位）

6261 (number.i和number.half共用一块地址空间，'a'对应的ASSII码为61）

 

实现部分库函数
4.1 已知strcpy的函数原型：char *strcpy(char *strDest, const char *strSrc)，其中strDest 是目的字符串，strSrc 是源字符串。不调用C++/C 的字符串库函数，请编写函数 strcpy、strlen、strcat。

#include"stdafx.h"
#include<cassert>
 
 
char* strcpy(char* strDest, const char* strSrc)
{
	if ((strDest == NULL || strSrc == NULL))
		throw"Invaild argument(s)";
	char * strDestCopy = strDest;
	while ((*strDest++ = *strSrc++) != '\0');
	return strDestCopy;
}
 
int strlen(const char* str)
{
	//assert()函数：如果参数为0，则终止程序
	assert(str);
	int len = 0;
	while (*str++)
	{
		len++;
	}
	return len;
}
 
char* strcat(char* strDest, const char* strSrc)
{
	assert(strDest && strSrc);
	char * pd = strDest;
	//若使用while(*Dest++)，则会出错，指向'\0'之后，会出现dest++,则指向了个'\0'的下一个位置， 
	while (*pd!='\0')
		pd++;
	while ((*pd++ = *strSrc++)!='\0');
	return strDest;
}
void main()
{
	char str1[25] = "adwadad";
	char str2[13] = "XX is best!!";
	//strcpy(str1, str2);
	strcat(str1, str2);
	printf("%s", str1);
}

错误的做法： 
[1] 
(A)不检查指针的有效性，说明答题者不注重代码的健壮性。 
(B)检查指针的有效性时使用((!strDest)||(!strSrc))或(!(strDest&&strSrc))，说明答题者对C语言中类型的隐式转换没有深刻认识。在本例中char *转换为bool即是类型隐式转换，这种功能虽然灵活，但更多的是导致出错概率增大和维护成本升高。所以C++专门增加了bool、true、false三个关键字以提供更安全的条件表达式。
(C)检查指针的有效性时使用((strDest==0)||(strSrc==0))，说明答题者不知道使用常量的好处。直接使用字面常量（如本例中的0）会减少程序的可维护性。0虽然简单，但程序中可能出现很多处对指针的检查，万一出现笔误，编译器不能发现，生成的程序内含逻辑错误，很难排除。而使用NULL代替0，如果出现拼写错误，编译器就会检查出来。
[2] 
(A)return new string("Invalid argument(s)";，说明答题者根本不知道返回值的用途，并且他对内存泄漏也没有警惕心。从函数中返回函数体内分配的内存是十分危险的做法，他把释放内存的义务抛给不知情的调用者，绝大多数情况下，调用者不会释放内存，这导致内存泄漏。
(B)return 0;，说明答题者没有掌握异常机制。调用者有可能忘记检查返回值，调用者还可能无法检查返回值（见后面的链式表达式）。妄想让返回值肩负返回正确值和异常值的双重功能，其结果往往是两种功能都失效。应该以抛出异常来代替返回值，这样可以减轻调用者的负担、使错误不会被忽略、增强程序的可维护性。
[3] 
(A)忘记保存原始的strDest值，说明答题者逻辑思维不严密。 
[4] 
(A)循环写成while (*strDest++=*strSrc++);，同[1](B)。 
(B)循环写成while (*strSrc!='\0') *strDest++=*strSrc++;，说明答题者对边界条件的检查不力。循环体结束后，strDest字符串的末尾没有正确地加上'\0'。

2.返回strDest的原始值使函数能够支持链式表达式，增加了函数的“附加值”。同样功能的函数，如果能合理地提高的可用性，自然就更加理想。 
链式表达式的形式如： 
        int iLength=strlen(strcpy(strA,strB)); 
又如： 
        char * strA=strcpy(new char[10],strB); 
返回strSrc的原始值是错误的。其一，源字符串肯定是已知的，返回它没有意义。其二，不能支持形如第二例的表达式。其三，为了保护源字符串，形参用const限定strSrc所指的内容，把const char *作为char *返回，类型不符，编译报错。

5.定义String对象，并实现成员函数：

#include "stdafx.h"
#include <cstring>
 
class String
{
public:
	String(const char *str = nullptr);// 通用构造函数
	String(const String &another); // 拷贝构造函数
	~String(); // 析构函数
	String& operator= (const String &rhs); // 赋值函数
private:
	char* m_data; // 用于保存字符串
};
String::String(const char* str)
{
	if (str)
	{
		m_data = strcpy(new char[strlen(str) + 1], str);
	}
	else
	{
		m_data = new char;
		m_data = '\0';
	}
}
String::String(const String &another)
{
	m_data = strcpy(new char[strlen(another.m_data) + 1], another.m_data);
}
String::~String()
{
	delete[] this->m_data;
}
String& String::operator=(const String & ob)
{
	if (this != &ob)
	{
		delete[] this->m_data;
		m_data = strcpy(new char[strlen(ob.m_data)+1], ob.m_data);
	}
	return *this;
}

6.如何判断一段程序是由C 编译程序还是由C++编译程序编译的？

1 #ifdef __cplusplus
2     cout << "cplusplus" << endl;
3 #else
4     cout << "c" << endl;
5 #endif

6.智能指针：
类中有指针成员时，有两种方法管理指针成员：1.值型的方式管理
7.智能指针：使用引用计数，将计数器与类指向的对象相关联，（赋值）引用则加一，（析构）反之减一，为0则删除。
8.继承：实现继承、接口继承、可视继承
9.为什么基类的析构函数是虚函数？
因为派生类的指针可以安全地转化为基类的指针，所以删除一个指针时调用的是基类的析构函数而不是派生 类的，
所以要重写基类的析构函数来释放资源
10.还不知道对象的准确类型，所以不能调用虚函数，所以构造函数不能是虚函数
11.虚函数不能滥用：因为虚函数对象需要维护虚函数表，形成系统开销，故不宜滥用
12.受保护的继承：基类成员只能被直接派生类访问，派生类 的子类不可以访问
13.私有继承：基类中的成员不可以被派生类访问
14.公有继承时，受保护的成员可由派生类访问，但不可以修改。
15.const成员和引用成员只可以用构造函数初始化列表，但是不可以赋值初始化。
16.虚指针是虚函数的实现细节，带有虚函数的每一个对象都有指向该函数的虚函数表
17.c++如何阻止一个类被实例化？
将类定义为抽象类或者将构造函数声明为私有的
18.什么时候将构造函数声明为私有的？
不允许在类的外部创建类的对象，只允许在类内部创建类的对象时
19.如何编写Sockt套接字
服务端：先调用socket创建一个套接字...
客户端：先调用socket创建一个套接字...
调用函数时进行参数压栈，一般从右边往左边进行压栈
20.经常要操作的内存分为哪几个类别：（5）
21.堆和栈的区别（3）
1.申请方式
2地址扩展、内存大小
3.速度快慢、产生碎片
22.类使用static成员的优点？（3）
1.static成员的名字是在类的作用域中，因此可以避免与其他类或全局对象名字冲突
2.可以实施封装，static成员可以是私有的，而全局对象不可以，
3.static成员与特定类关联，可清晰地显示程序员的意图
23.**static数据成员与static成员函数？
42题
24.static关键字的作用？
静态存储、内部连接（两种情况）