C++刷题笔记（一）

最新推荐文章于 2024-07-30 11:25:37 发布

MyLinChi

最新推荐文章于 2024-07-30 11:25:37 发布

阅读量1.4k

点赞数 2

分类专栏： c/c++

本文链接：https://blog.csdn.net/mylinchi/article/details/78295626

版权

c/c++ 专栏收录该内容

91 篇文章 10 订阅

订阅专栏

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

输出结果：