C++基础知识学习

1、system(“pause”) 　　　　　　 //方便观察结果
2、new delete　　　　　　　　 //内存的申请与释放
　申请单个空间：　　　int *p=new int(10);
　　　　　　　　　　或int *p=new int;　　*p=10;
　　　　　　　　　　delete p;
　申请数组空间：　　　int *p=new int[2];　　　2表示数组个数
　　　　　　　　　　p[0]=2;
　　　　　　　　　　p[1]=10;
　　　　　　　　　　或int p=new int[2];
　　　　　　　　　　memset(p,0,24)　　　其中的第二个是要赋的值，这里全部赋为0，第三个是字节数，一个int有4字节
　　　　　　　　　　delete[] p;
3、*的三种作用：
　　(1)声明变量的时候用，表示该变量是指针变量
　　int a=12;
　　int *p=&a;
　　(2) *　加上一个地址，表示地址操作符
　　(3)乘法作用
4、引用：给变量起别名
　int a=12;
　int& c=a;　　　　//这里的&不再是取地址符，c是变量a的一个别名
　c=13;
　cout<<c<<endl;　　　　//此时输出的是13
5、命名空间：区分同名变量或函数
　（1）创建：namespace 名字　{code}　　　　名字不可以重复
　（2）使用方法：a、using namespace 名字
　　　　　　　　 b、名字::变量名/函数
6、&的三种作用：
　（1）声明变量的时候用，表示引用
　（2）变量前边+&，表示取地址
　（3）数&数表示位与运算
7、定义函数时可以指定：
　void fun(int a=12,char c=“c”)　　　　　　　　　-----全部指定
　void fun1(int a,char c=“c”,float f=123.123)　 　　-----部分指定，必须从右向左连续指定
　void fun1(int a=12,char c,float f=123.123)　　　 ----- 报错
在函数调用时，指定默认值了，可以不用传递实参-----fun()
没指定默认值，一定要传递实参------fun1(123)
有默认值，还传递实参，实参会将默认值覆盖掉
注意 ：当main函数写在这些函数前面的时候，只需要在最前面函数声明时指定值，后面的函数定义不需要指定值了
8、防止头文件重复包含：#pragma once
9、拷贝构造
系统默认的拷贝构造是浅构造：

#include <iostream>

using namespace std;

class CStu
{
public:
	CStu()
	{

	}
	//拷贝构造的形式
	CStu(const CStu& a)
	{

	}
};

void fun(CStu a)
{

}

CStu fun()
{
	CStu a;
	return a;
}

int main()
{
	CStu stu1;
	//拷贝构造的调用
	//1、新建一个对象，并将其初始化为同类现有对象
	CStu stu2(stu1);
	CStu stu3 = stu1;
	CStu stu4 = CStu(stu1);//通过临时对象赋值
	CStu* stu5 = new CStu(stu1);//通过指针

	//该情况下不会调用拷贝构造
	CStu stu6;
	stu6 = stu1;

	//2、当程序生成对象副本时--函数参数返回对象的值
	fun(stu1);

	//当程序生成对象副本时--函数返回对象
	CStu(st2);
	system("pause");
	return 0;
}

深拷贝：
CStu()
{
	a = new int[2];
	a[0] = 12;
	a[1] = 13;
}
CStu(const CStu& b)
{
	this->a = b.a;//浅拷贝
	//深拷贝
	//1、申请空间
	this->a = new int[2];
	this->a[0] = b.a[0];
	this->a[1] = b.a[1];
}

10、内联函数：
　　1）作用：用相应的代码替换调用
　　2）比常规函数稍快，代价是占用更多内存
　　3）声明方式：

inline void fun()
{

}

用常规函数还是内联函数，看实际需要，是注重效率还是内存空间
类与内联函数：
　　1）类内定义的都是内联函数
　　2）类内声明，类外定义的不是内联函数，要想内联要自己加inline
并且在多文件时，不同于常规函数，内联函数的定义要写在头文件中
11、运算符重载

#include <iostream>
using namespace std;

class CStu
{
public:
	int age;
	double score;
	CStu()
	{
		age = 12;
		score = 12.12;
	}
};
//运算符+的重载
void operator+(CStu& st, int a)
{
	cout << (st.age + a) << endl;
}

int main()
{
	CStu st1;
	st1 + 12;
	return 0;
}

通过运算符重载的返回值**（return）**可以进行连续运算
如果是类内重载运算符：

class CStu
{
public:
	int age;
	double score;
	CStu()
	{
		age = 12;
		score = 12.12;
	}
	int operator+(int a)
	{
		return (age + a);
	}
};

但是有局限性，左边的默认的是类
输出运算符的重载：

void operator << (ostream& os, const CStu& st)
{
	os << st.age;
}

main函数中调用：

CStu st;
cout << st;

连续输出运算符的重载：

#include <iostream>
using namespace std;

class CStu
{
private:
    int age;
public:	
	CStu()
	{
		age = 12;
	}
	friend ostream& operator << (ostream& os, const CStu& st);//友元，使private的成员可以调用
};

ostream& operator << (ostream& os, const CStu& st)//当参数不进行修改时，注意要加const
{
	os << st.age;
	return os;
}
int main()
{
	CStu st;
	cout << st << st;
	system("pause");
	return 0;
}

输入运算符重载：

#include <iostream>
using namespace std;

class CStu
{
private:
	int age;
public:
	CStu()
	{
		age = 12;
	}
	void show()
	{
		cout << age << endl;
	}
	friend istream& operator >> (istream& ist, CStu& st);
};

istream& operator >> (istream& ist, CStu& st)
{
	ist >> st.age;
	if (ist.fail)//判断输入值是否正确
	{
		cout << "输入有问题" << endl;
	}
	return ist;
}
int main()
{
	CStu st;
	cin >> st;
	st.show();
	system("pause");
	return 0;
}
赋值运算符的**=**必须类内重载，否则会报错
复合赋值运算符：+=，-=，/=，*=，%=，<<=，>>=，^=，&=，|=等，建议类内重载，类外也行

12、继承：当许多类中都有一个公共属性时，为减少重复性，可以将该属性放在一个基础类中，拥有该属性的类通过继承来得到该属性

#include <iostream>

using namespace std;

//小孩和大人都需要学习，所以study是公共类
//被继承的类叫基类或父类
class Cpeople
{
public:
	void study()
	{
		cout << "study" << endl;
	}
	void fun1()
	{
		cout << "public" << endl;
	}
protected:
	void fun2()
	{
		cout << "protected" << endl;
	}
private:
	void fun3()
	{
		cout << "private" << endl;
	}
};
//继承了Cpeople
//称为派生类或子类
//三种限定词的作用是不一样的
//public:父类怎么样，子类就怎么样
//protected:继承之后，父类的public降级为protected，父类的protected和private不变
//private:全变private
class Cchild : protected Cpeople
{
public:
	void school()
	{
		cout << "school" << endl;
	}
};

int main()
{
	Cchild child;
	child.study();//调用了父类的函数
	child.
	system("pause");
	return 0;
}

继承构造的调用顺序：先父类，再子类