在C++primer(第5版)中关于new的讨论有：
1、new当个对象
new在自由空间分配内存，但其无法为其分配的对象命名，因次是无名的，分配之后返回一个指向该对象的指针。
| 1 |
|
此new表达式在自由空间构造一个int类型对象，并返回指向该对象的指针。
默认情况下，动态分配的对象是默认初始化的，这意味着内置类型或组合类型的对象的值是无定义的，而类类型对象将用默认构造函数进行初始化。
2、new(多个对象)数组
new分配的对象，不管单个对象还是多个对象的分配，都是默认初始化。但可以对数组进行值初始化，方法就是：在大小之后添加一对空括号。
| 1 2 |
|
3 下面的程序可以从0....n-1中随机等概率的输出m个不重复的数。这里我们假设n远大于m
#include<iostream>
#include<ctime>
#include<cstdlib>
using namespace std;
knuth(int n, int m)
{
srand((unsigned int)time(0));
for (int i = 0; i < n; i++) {
if ( rand()%(n-i)<m) {
cout << i << endl;
(m-- );
}
}
}
int main()
{
knuth(1000,5);
return 0;
}由这个for循环循环n次，且在满足条件时才输出i,可知，输出m个不同值的要求已满足，因为每次输出的都是i值，而i值每次都是不一样的，m--保证了程序在输出了m个值后就停止循环。
在i=0时，rand()%(n-i)的取值范围为0到n-1，共n个数，此时要输出0只需要rand()%(n-i)小于m，故i=0被输出的概率为m/n;
在i=1时，rand()%(n-i)的取值范围为0到n-2，共n-1个数，若i=0没有被输出，则m--未被执行，此时i=1被输出的概率为m/(n-1)，若i=0已经被输出了，则m变为m-1，此时i=1被输出的概率为(m-1)/(n-1)；由概率论的知识，可知此时i=1被输出的概率为
P=(1-m/n)*(m/(n-1))+m/n*((m-1)/(n-1))=m/n；以此类推，可知每个数被输出的概率都为m/n
4.
unsigned char *p1;
unsigned long *p2;
p1=(unsigned char *)0x801000;
p2=(unsigned long *)0x810000;
请问p1+5= 什么？
p2+5= 什么？
解析：p1指向字符型，一次移动一个字符型，1个字节；p1+5后移5个字节，16进制表示为5；
p2指向长整型，一次移动一个长整型，4个字节，p2+5后移20字节，16进制表示为14。
{ char每次移动1个字节；short移动2个字节 ；int , long ,float移动4个字节 ；double移动8个字节}
同理下面这个问题的输出是 "to test something"
har str[] = "glad to test something";
char *p = str;
p++;
int *p1 = reinterpret_cast<int *>(p);
p1++;
p = reinterpret_cast<char *>(p1);
printf("result is %s\n", p);p的类型为char *，p++后p指向str数组的第2个元素即字母“l”的位置。
p1的类型为int *，p1++后p1指向的位置增加4个字节，指向str数组中的第6个元素即字母“t”的位置。
因此最后p的内容为“to test something”。
5.
在32位机器中，如下代码：
void example(char acWelcome[]){
printf("%d",sizeof(acWelcome));
return;
}
void main(){
char acWelcome[]="Welcome to Huawei Test";
example(acWelcome);
return;
}的输出是：
数组当作参数传递时，它就退化成指针了，要求数组长度的话，可以在main函数内部求得
指针在实质上是一个内存地址，内存地址的长度跟CPU的寻址有关。
在32位系统上， CPU用32位表示一个内存地址。这样的系统上一个指针占据4个字节。
在64位系统上， CPU用64位表示一个内存地址。这样的系统上一个指针占据8个字节。
6.虚函数和函数重载
虚函数也是类的成员函数
虚函数和函数重载都实现了C++的多态性，但表现形式不一样，函数重载调用根据参数个数、参数类型等进行区分，而虚函数则是根据动态联编来确定调用
函数重载可以是类的成员函数也可以是非成员函数
虚函数必须是成员函数了，否则就失效
虚函数和纯虚函数的区别
虚函数可以在子类中进行重载，也可以不重载而沿用父类中的方法。但纯虚函数必须重载，因为在其声明类中没有函数实现。vritual void func（）=0；
包含纯虚函数的类为抽象类，抽象类不能声明对象，只能作为基类
7.析构函数调用顺序'
C c;
void main()
{
A*pa=new A();
B b;
static D d;
delete pa;
}这道题主要考察的知识点是 ：全局变量，静态局部变量，局部变量空间的堆分配和栈分配
其中全局变量和静态局部变量时从 静态存储区中划分的空间，
二者的区别在于作用域的不同，全局变量作用域大于静态局部变量（只用于声明它的函数中），
而之所以是先释放 D 在释放 C的原因是， 程序中首先调用的是 C的构造函数，然后调用的是 D 的构造函数，析构函数的调用与构造函数的调用顺序刚好相反。
局部变量A 是通过 new 从系统的堆空间中分配的，程序运行结束之后，系统是不会自动回收分配给它的空间的，需要程序员手动调用 delete 来释放。
局部变量 B 对象的空间来自于系统的栈空间，在该方法执行结束就会由系统自动通过调用析构方法将其空间释放。
之所以是 先 A 后 B 是因为，B 是在函数执行到 结尾 "}" 的时候才调用析构函数， 而语句 delete a ; 位于函数结尾 "}" 之前。
8.若char是一字节，int是4字节，指针类型是4字节，代码如下：
class CTest
{
public:
CTest():m_chData(‘\0’),m_nData(0)
{
}
virtual void mem_fun(){}
private:
char m_chData;
int m_nData;
static char s_chData;
};
char CTest::s_chData=’\0’;问：
（1）若按4字节对齐sizeof(CTest)的值是多少？
（2）若按1字节对齐sizeof(CTest)的值是多少？
4字节对齐，结果是12= 4（虚表指针）+1（char )+3(对齐补位）+4（int)
1字节对齐，结果是9 =4（虚表指针）+1（char )+4（int)
在类中，如果什么都没有，则类占用1个字节，一旦类中有其他的占用空间成员，则这1个字节就不在计算之内，如一个类只有一个int则占用4字节而不是5字节。
如果只有成员函数，则还是只占用1个字节，因为类函数不占用空间
虚函数因为存在一个虚函数表，需要4个字节，数据成员对象如果为指针则为4字节，注意有字节对齐，如果为13字节，则进位到16字节空间。
static的成员变量属于类域，不算入对象中,静态成员变量存储在静态存储区，编译时完成初始化，独立于类的实例，不算在类的大小中.
9.写出下面程序的输出结果
class A
{
public:
void FuncA()
{
printf( "FuncA called\n" );
}
virtual void FuncB()
{
printf( "FuncB called\n" );
}
};
class B : public A
{
public:
void FuncA()
{
A::FuncA();
printf( "FuncAB called\n" );
}
virtual void FuncB()
{
printf( "FuncBB called\n" );
}
};
void main( void )
{
B b;
A *pa;
pa = &b;
A *pa2 = new A;
pa->FuncA(); （ 3）
pa->FuncB(); （ 4）
pa2->FuncA(); （ 5）
pa2->FuncB();
delete pa2;
}B b;
A *pa;
pa = &b;
A *pa2 = newA;
pa->FuncA(); （ 3）//pa=&b动态绑定但是FuncA不是虚函数，所以FuncA called
pa->FuncB(); （ 4）//FuncB是虚函数所以调用B中FuncB，FuncBB called
pa2->FuncA(); （ 5）//pa2是A类指针，不涉及虚函数，调用的都是A中函数，所以FuncA called FuncB called
pa2->FuncB()
父类指针指向子类实例对象，调用普通重写方法时，会调用父类中的方法。而调用被子类重写虚函数时，会调用子类中的方法。
10.浅/深拷贝操作 和 赋值操作
#include<iostream>
using namespace std;
class MyClass
{
public:
MyClass(int i = 0)
{
cout << i;
}
MyClass(const MyClass &x)
{
cout << 2;
}
MyClass &operator=(const MyClass &x)
{
cout << 3;
return *this;
}
~MyClass()
{
cout << 4;
}
};
int main()
{
MyClass obj1(1), obj2(2);
MyClass obj3 = obj1;
return 0;
}运行时的输出结果是（122444）
没有重载=之前：
A a ;
A b;
a = b;
这里是赋值操作。
A a;
A b = a;
这里是浅拷贝操作。
重载 = 之后：
A a ;
A b;
a = b;
这里是深拷贝操作（当然这道题直接返回了，通常我们重载赋值运算符进行深拷贝操作）。
A a;
A b = a;
这里还是浅拷贝操作。
所以 MyClass obj3 = obj1; 调用的是拷贝构造函数。
如果写成 MyClass obj3; obj3 = obj1; 输出的结果就是 1203444
C MyClass obj3 = obj1;
obj3还不存在，所以调用拷贝构造函数输出2，
如果obj3存在，obj3=obj，则调用复制运算符重载函数，输出3
11.
把*读作"pointer to"，从右至左念：
b是一个常量
const int b; /* b is a int const */
int const b; /* b is a const int */
p是一个普通指针，指向一个常量
const int *p; /* p is a pointer to int const */
int const *p; /* p is a pointer to const int */
p是一个常量指针，指向一个普通变量
int *const p; /* p is a const pointer to int */
p是一个常量指针，指向一个常量
const int *const p; /* p is a const pointer to int const */
int const *const p; /* p is a const pointer to const int */
1.如果const位于*号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量。
2.如果const位于*号的右侧，const就是修饰指针本身，即指针本身是常量。
12.
class B
{
public:
virtual void Fun(){}
};
class D: public B
{
public:
void Fun(){}
};
D dd;
B* pb = ⅆ
D* pd = ⅆ
pb->Fun();
pd->Fun();上述例程调用的Fun函数顺序为？（ ）
本题考察两个知识点：
一、赋值兼容：
1.子类对象可以赋值给父类对象
2.子类对象可以初始化父类对象
3.父类指针可以指向子类对象
4.父类引用可以引用子类对象
二、子类重写父类
这两个知识点也就是解释多态的关键
本题中，根据兼容性原则：当父类指针（引用）指向子类对象时，子类对象退化成父类对象，只能访问父类中定义的成员
如果B对象没有virtual修饰的话，B* pb = ⅆ dd就会退化为父类对象，pd就只能访问父类的成员B::Fun()。
但是又virtual修饰的话，就会展现多态行为，会根据实际指针指向的对象判断函数的调用。pb 和pd都指向子类对象，所以调用D::Fun()。
13.
32位编译器：32位系统下指针占用4字节
char ：1个字节
char*（即指针变量）: 4个字节（32位的寻址空间是2^32, 即32个bit，也就是4个字节。同理64位编译器）
short int : 2个字节
int： 4个字节
unsigned int : 4个字节
float: 4个字节
double: 8个字节
long: 4个字节
long long: 8个字节
unsigned long: 4个字节
64位编译器：64位系统下指针占用8字节
char ：1个字节
char*(即指针变量): 8个字节
short int : 2个字节
int： 4个字节
unsigned int : 4个字节
float: 4个字节
double: 8个字节
long: 8个字节
long long: 8个字节
unsigned long: 8个字节
扫一扫
1940
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
