C++笔记1

柔情只为你懂 2022-08-07 08:52 110阅读 0赞

1、用\#define声明一个常数，用以表明1年中有多少秒?

\#define SECONDS\_PER\_YEAR (60 \* 60 \* 24 \*365)UL

UL：无符号长整型

2、类成员的初始化，初始化列表的初始化顺序与变量声明的顺序一致，而不是安照出现在初始化列表中的顺序。

#include<iostream>
    using namespace std;
    
    class Obj
    {
    public:
    	Obj(int k) :j(k), i(j){}
    	void print(void)
    	{
    		cout << i << endl << j << endl;
    	}
    private:
    	int i;
    	int j;
    
    };
    
    int main()
    {
    	Obj obj(2);
    	obj.print();
    	cout << endl;
    }

3、静态成员函数和静态成员变量一样，不属于类的对象，因此它不含this指针，也就是无法调用类的非静态成员

非静态成员可以调用静态成员函数和对象

#include<iostream>
    using namespace std;
    
    class Obj
    {
    public:
    	Obj(int k) :j(k), i(j){}
    	void print(void)
    	{
    		cout << i << endl << j << endl<<d<<endl;
    		A();
    	}
    	static void A()
    	{
    		cout << d << endl;
    	}
    private:
    	int i;
    	int j;
    	static int d;
    
    };
    int Obj::d = 100;
    
    int main()
    {
    	Obj obj(2);
    	obj.print();
    	cout << endl;
    }

![Image 1][]

4、C++中空类默认会产生那些类成员函数

1）默认构造函数和复制构造函数。它们被用于类的对象的构造过程

2）析构函数。它用于类的对象的析构过程

3）赋值函数。它被用于同类的对象间的赋值过程

4）取值运算。当对类的对象进行取地址（&）时，此函数被调用

例：

<pre name="code" class="cpp">class Empty
    {
    public:
    	Empty();							//缺省构造函数
    	Empty(const Empty&);						//复制构造函数
    	~Empty();							//析构函数
    	Empty& operator=(const Empty&);		//复制运算符
    	Empty* operator&();			//取地址算符
    	const Empty* operator&() const;		//取地址算符 const
    };

5、构造函数可以被重载。因为构造函数可以有多个，且可以带参数

析构函数不可以被重载。因为析构函数只能有一个，切不能带参数

6、位、字节、字

位(Bit):：在计算机中，数据的最小单位是位，表示一个二进制数码0或1  
字节（Byte） ：8个二进制位构成1个字节（B），1个字节可以储存1个英文字母或半个汉字。字节是存储空间的基本计量单位  
字长：电脑技术中对CPU在单位时间内(同一时间)能一次处理的二进制数的位数  
字(Word) ：不同计算机系统中占据一个单独的地址(内存单元的编号)并作为一个单元(由一个或多个字节组合而成)处理的一组二进制数。8位的CPU字长为8位，一个字等于一个字节，一次只能处理一个字节，而32位的CPU字长为32位，一个字等于4个字节，一次就能处理4个字节，同理字长为64位的CPU一次可以处理8个字节，一个字等于8个字节。

7、构造函数的相互调用引起的后果不是死循环，而是栈溢出。

8、explicit构造函数与普通构造函数的区别

explicit构造函数是用于防止隐式转换。代码如下。

![Image 1][]

class Test1
    {
    public:
    	Test1(int n){ num = n; }
    private:
    	int num;
    };
    
    class Test2
    {
    public:
    	explicit Test2(int n){ num = n; }
    private:
    	int num;
    };
    int main()
    {
    	Test1 t1 = 12;		//隐式调用其构造函数，成功
    	Test2 t2 = 12;		//编译错误，不能隐式调用其构造函数
    	Test2 t3(12);		//显示调用成功
    	return 0;
    }

explicit构造函数的作用

class Number
    {
    public:
    	string type;
    	Number() :type("void"){}
    	explicit Number(short) :type("short"){}
    	Number(int) :type("int"){}
    };
    
    void Show(const Number& n)
    {
    	cout << n.type << endl;
    }
    
    int main()
    {
    	short s=42;
    	Show(s);
    }

![Image 1][]

原因，在调用Show(s)时采用了一下步骤。

（1）Show(s)中的s为short类型，其值为42，因此首先检查参数为short的构造函数能否被隐式转换，结果不能被隐式转换。于是进行下一步

（2）42自动转换为int类型

（3）检查参数为int的构造函数能否被隐式转换，由于参数为int的构造函数没有被声明为显式调用，因此调用此构造函数构造出一个临时对象。

（4）打印上一步临时对象的type成员，即“int”。

9、C++中，下面是3种对象需要复制的情况。因此，复制构造函数将会被调用

（1）一个对象以值传递的方式传入函数体

（2）一个对象以值传递的方式从函数返回。

（3）一个对象需要通过另外一个对象进行初始化。

10、为什么要去自定义复制构造函数？

#include<iostream>
    using namespace std;
    
    class Test
    {
    public:
    	char *buf;
    	Test(void)
    	{
    		buf = NULL;
    	}
    	Test(const char* str)
    	{
    		buf = new char[strlen(str) + 1];
    		strcpy_s(buf,  strlen(str) + 1,str);
    	}
    	~Test()
    	{
    		if (buf != NULL)
    		{
    			delete buf;
    			buf = NULL;
    		}
    	}
    };
    
    int main()
    {
    	Test t1("hello");
    	Test t2 = t1;
    	cout << "(t1.buf == t2.buf)?" << (t1.buf == t2.buf ? "yes" : "no") << endl;
    	return 0;
    }

程序的执行结果如下

1 （t1.buf == t2.buf) ? yes

2 程序崩溃

原因：默认复制构造函数只是简单地把两个对象的指针做赋值运算，它们指向的是同一个地址。当产生两次析构，释放同一块堆内存时发生崩溃。

解决方法：在Test类里通过添加一个自定义的复制构造函数解决两次析构的问题

Test(Test &test)
    	{
    		buf = new char[strlen(test.buf) + 1];
    		strcpy_s(buf, strlen(test.buf) + 1, test.buf);
    	}

程序运行结果：

![Image 1][]

11、浅复制与深复制

浅复制是指让新旧两个对象指向同一个外部的内容（例如分配在堆上的数据），而深复制是指为新对象制作了外部对象的独立复制。

12、复制构造函数与赋值函数区别

（1）复制构造函数是一个对象来初始化一块内存区域，这快内存就是新对象的内存区