c++一些基础小知识

命名空间

using 命名空间::变量

//用来声明变量属于哪个命名空间

当我们在代码中使用using namespace std时，下面没有指定明明空间的符号都默认使用std

gcc编译器的使用

linu里面用来编译c++文件的命令：
g++ main.cpp module.cpp -o demo1 demo2 //指定可执行文件名称

输入输出流
c++中需要使用输入输出时。需要包含头文件iostream cerr表示错误输出
注意：cout和cin都是c++的内置对象，而不是关键字。c++定义了大量的类，cin和cout就是istream和ostream类的对象，只不过他们是标准库开发者提前创建好的，可以直接拿来使用，这种提前创建好的对象称为内置对象。endl表示换行。

cin>>x>>y;  //cin连续输入

new和delete关键字
new用来动态分配内存 delete用来释放内存

int *p=new int;
delete p;

//如果需要分配一组连续的数据，可以使用new[]
int *p=new int[10]; //分配十个int型的内存空间
delete[] p;

内联函数
为什么会有内联函数当执行一个只有一两条语句的函数时函数的调用机制占用时间相对执行函数的时间太长浪费时间开销内联函数在编译时将函数调用处用函数体替换这样在执行时就不用再去调用函数了

定义内联函数很简单只要在函数定义前面加inline关键字就行

inline void swap(int a,intb)
{
	int t;
	t=a;
	a=b;
	b=t;
}

函数重载的规则;
函数名必须相同
参数列表必须不同
返回类型可以相同也可以不同

堆和栈
栈内存是程序自动管理的，不能用delete删除在栈上的对象；
堆是由程序员来管理的可以用new和delete来管理；
程序在执行一个函数之前需要做一些准备工作，要将实参、局部变量、返回地址以及若干寄存器都压入栈中，然后才能执行函数体中的代码

类的成员函数
定义在类内部的成员函数默认为inline函数所以建议一般在类内部声明成员函数在类外部编译成员函数
这要编译出来的程序不会过大

构造函数
构造函数没有返回类型而且类必须要有构造函数
默认构造函数：默认构造函数无任何实参
合成的默认构造函数：编译器创建的构造函数
一旦用户自己定义了构造函数，不管有几个，也不管形参如何，编译器不会再自动生成。
如果类成员函数是const类型，必须通过初始化列表赋值，例如：

class vla{
private:
	const int m_len;
	const int *arr;
public:
	vla(int len):m_len(len) {ar=new int[len]};
	}

析构函数
析构函数也是一种特殊的成员函数，没有返回值，没有参数，不需要程序员显式的调用，而在销毁对象时自动执行。
析构函数的函数名和类名相同，只是在前面加了一个~符号。
析构函数不能被重载，所以一个类只有一个析构函数，如果用户没有定义，编译器会自动生成一个默认的析构函数。

class vla{
public:
	vla(int a):m_len(a) {};
	~vla();
	}
 vla::~vla() {
 delete[] m_arr;
 }

静态变量
静态变量无关于具体的类对象，在类内声明，在类外定义，无论初始化了多少个类对象，也只会为静态成员分配一个内存块
且静态成员的内存不是在声明时分配，而是是初始化时分配，所以说，没有初始化的静态成员不能使用

class student
{
public:
	student(char *name,int age,float score);
	void show();
public:
	static int m_total;
private:
	char *m_name;
	int m_age;
	float m_score;
}
//静态变量初始化
//<type> class::name=value;
int student::m_total=0;

静态变量的访问

//通过类访问
student::m_total=10;
//通过对象访问
student stu("李华",15,90);
stu.m_total=10;
//通过对象指针来访问
student *p=new student("李华",15,90);
p->m_total=20;

静态函数
静态函数只能调用静态变量静态函数可以通过类名直接引用
注意一点普通函数都会隐式的传入一个形参this 所以普通函数必须通过对象来引用静态函数不用传

友元
可以把其他类的成员函数或全局函数声明为友元来访问类的private成员变量

class student{
public:
	student(string name,int score,int age):_name(name),_score(score),_age(age);
	friend void show(student *p);
private:
	std::string _name;
	float _score;
	int _age;
}

void  show(student* p)  //类的友元函数不同于类的成员函数 不能直接访问成员变量 只能通过对象来访问
{
cout<<p->_name<< "的分数是"<<p->_score;
}

int main{}
{
	student stu("小明"，90,15)；
	show(&stu);
}

把其他类的成员函数声明为友元

class Address; //注意要提前声明类                                                                                                                                                                                     

class student{
public:
	student(string name,int score,int age):_name(name),_score(score),_age(age) {};
	void get_address(Address *p） const ;
private:
	std::string _name;
	float _score;
	int _age;
}

class Address{
public:
"构造函数"
friend void student::get_address(Address *p);
private:
string address;
}

void student::get_address(Address *p） const
 { 
 	cout<<p->address<<endl;
 }

int main()
{
	student stu("小明"，90,15)；
	address add("四川省成都市");
	stu.get_address(&add);
	return 0;
}

友元类
可以直接把一个类声明为另一个类的友元类中的所有成员函数都是另一个类的友元函数

c++一些基础小知识

猜你喜欢