C++刷题笔记(一)

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/MyLinChi/article/details/78295626

1.数组的初始化

int *p1=new int[10];该语句给指针p1分配内存,没有对指针初始化, 

int *p2=new int[10]();该语句给指针p2分配内存,并初始化指针。


2.数组作为形参,实参会退化为指针

#include<iostream>
using namespace std;
void example(char acWelcome[]){
	cout << sizeof(acWelcome) << endl;
}
int main()
{
	char acWelcome[] = "Hello world!";
	cout << sizeof(acWelcome) << endl;
	example(acWelcome);
	system("pause");
	return 0;
}
输出结果:



3.sizeof是获得变量类型长度的运算符(单位:字节)

#include<iostream>
using namespace std;
int main()
{
	int a[100];
	int *pa = a;
	cout << sizeof(a) << endl;
	cout << sizeof(pa) << endl;
	cout << sizeof(*pa) << endl;
	system("pause");
	return 0;
}
输出结果:



4.析构函数调用顺序

#include<iostream>
using namespace std;

class A{
public:
	~A(){
		cout << "Kill A" << endl;
	}
};

class B{
public:
	~B(){
		cout << "Kill B" << endl;
	}
};

class C{
public:
	~C(){
		cout << "Kill C" << endl;
	}
};

class D{
public:
	~D(){
		cout << "Kill D" << endl;
	}
};

A a;

int main()
{
	B *pb = new B();
	C c;
	static D d;
	delete pb;
	return 0;
}
输出结果:


分析:A,D都属于静态存储区,但A为全局变量先被构造,因此析构函数调用在D之后。B为堆空间上分配的变量,需要手动删除,在delete pb;时调用析构函数。C为栈空间上分配的空间,在}时调用析构函数。


5.类的空间的计算方法

若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)的值是多少?
答案:12 9

分析:
类中成员变量,成员函数,静态变量与函数的空间位置如下图所示


①:4字节对齐,结果是12= 4(虚表指针)+1(char )+3(对齐补位)+4(int)

#include<iostream>
using namespace std;

#pragma pack(push) //保存对齐状态
#pragma pack(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';

#pragma pack(pop)  //恢复对齐状态

void main()
{
	cout << sizeof(CTest) << endl;
}
输出结果:

②:1字节对齐,结果是9 =4(虚表指针)+1(char )+4(int)

#include<iostream>
using namespace std;

#pragma pack(push) //保存对齐状态
#pragma pack(1)    //设定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';

#pragma pack(pop)  //恢复对齐状态

void main()
{
	cout << sizeof(CTest) << endl;
}
输出结果:



6.重载和重写的返回值

方法重载:返回值的类型可以不同,因为判断方法重载的方法主要是根据方法的参数不同来判定

方法重写:返回值类型需要相同,重写就是子类继承了父类的方法,并在此方法上重写属于自己的特征,既然是继承过来的,那么它的返回值类型就必须要相同。


7.浅/深拷贝操作和赋值操作的区分

#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;
}


输出结果:

分析:

赋值操作:
A a ;
A b;
a = b;
(未重载=)
浅拷贝操作:

A a ;
A b=a;
深拷贝操作:
A a ;
A b=a;
(已重载=)

所以 MyClass obj3 = obj1; 调用的是拷贝构造函数。

如果写成 MyClass obj3; obj3 = obj1; 输出的结果就是 1203444

其他相关知识点:



                                                                                                                                                                                                                                                                                             2017/10
                                                                                                                                                                                                                                                                                             于北京

          
展开阅读全文

没有更多推荐了,返回首页