C++基本语法

0:include ""和<>

<>是标准搜索,一般搜系统所带头文件

""会先搜索当前文件目录,然后标准搜索;自己写的文件一般用这种方式

 

1:静态数据成员

静态数据成员的初始化在类外,静态函数成员一种用途就是用来输出静态数据成员,因为他们都不需要构造类

 

2:有元函数

一般调用:

class A
{
public:
	void	pt(A *p)
	{
		cout<<p->m_nNum<<endl;
	}
private:
	int		m_nNum;
};
int _tmain(int argc, _TCHAR* argv[])
{
	A s;
	A q;
	s.pt(&q);

	return 0;
}

有元函数调用:

class A
{
public:
	friend void	pt(A *p)
	{
		cout<<p->m_nNum<<endl;
	}
private:
	int		m_nNum;
};
int _tmain(int argc, _TCHAR* argv[])
{
	A q;
	pt(&q);

	return 0;
}

有元函数和普通函数基本没有区别,但传入的对象可以访问自己的私有成员,并且调用和普通函数一样,不需要使用类

 

3:有元类

class A
{
	friend  class B; //这里不需要前向申明
private:
	int		m_nNum;
};
class B
{
public:
	void	oper()
	{
		A a;
		a.m_nNum=100;
	}
};

有元类还有个重要作用是:一个类如果设置其构造函数为Private,可以通过有元类的方式让另外一个类得以创建它

 

常量

1:下面两种方式是一样的:

const int a=100; //声明时必须赋值

int const a=100;

2:指针常量:

int * const p=&a;  //p不能指向其他对象,但*p能更改

3:指向常量的指针

int const *p;        //可以不赋初值,*p不能更改,但p能指向其他对象

 

4:常引用

void WCG(const int& n)  //函数中不能更改n的值

 

5:常对象

A const a(1,2); 
int const n=10;
n=20;//Error

常对象不能被更新,为了满足这个要求,所以定义了两个条件:
1:常对象不能访问公有数据成员
2:常对象不能访问普通成员函数,而只能访问常成员函数

 

6:常成员函数

void  A::WCG()const
{

}

1:const和非const同名函数能够形成重载

2:常成员函数不能更新数据成员,也不能访问普通函数

3:普通对象能够调用常成员函数

一个函数如果声明为常成员函数,也就是做出了一个保证:此函数绝对不会修改对象数据,但它也不能访问普通类函数

 

7:常数据成员

1:其初始化赋值必须通过构造函数的初始化列表

2:如果是静态常数据成员,只能通过类外像静态数据成员一样的初始化,或者直接申明时初始化(需要编译器支持,vs2008支持)

class A
{
public:
	A(int a):m_n(a)
	{

	}
private:
	const  int m_n;
	static const int m_sn;
};
const int m_sn=100;

 

8:关于写不写virtual

如果基类写了virtual,覆盖它的子类写不写virtual都可以实现多态

 

9:拷贝构造函数和运算符重载

class A
{
public:
	A(int a):m_n(a){};
	A(A &a){}				//拷贝构造函数
	A operator +(A a)		//重载+(双目运算符)
	{
		return A(m_n+a.m_n);
	}
	bool operator ==(A a)	//重载==(双目运算符)
	{
		return m_n==a.m_n;
	}

	A& operator++()			//前置单目运算符
	{
		++m_n;
		return *this; 
	}
	A  operator++(int)		//后置单目运算符,int只是为了区别是后置的而已
	{
		A old=*this;
		++(*this);
		return old;
	}
private:
	int		m_n;
};

 

10:指针位置

定义一个int a=0x12345678,此时&a指向的是地址低的地方,也就是指向78处