C++基础验证篇（一）

一、class成员默认私有，struct成员默认公有
#include
using namespace std;


class CPoint
{
int x;
void print()
{


}
public:
CPoint(int x,int y)
{
this->x = x;
this->y = y;
}
void print1()
{


}
};




struct Spoint
{
int x;
int y;
void printf()
{


}
Spoint(int x, int y)
{
this->x = x;
this->y = y;
}
private:
void print1()
{


}
/* data */
};


int main()
{
CPoint cpt(1,2);
Spoint spt(3,4);
cout<< cpt.x<< cpt.y; //error
cpt.print();  //error
cpt.print1();


cout<< spt.x < spt.print();  
spt.print1(); //error
}

在类的继承方式上，struct和class的区别是class继承默认是私有继承，struct继承默认是公有继承。以private方式继承父类的子类对象不能访问父类的public成员。
同时，class可以用于表示模板类型，而struct不行。

二，类中的两个构造函数，一个带参数，一个不带参数，调用不带参数的构造函数时，是不需要小括号的。
struct Test
{
Test(int){}
Test(){}
void fun(){}
};
void  main(void)
{
Test a(1);
a.fun();
Test b();//error应为Test b;
b.fun(); 
return 0;
}
三、类对象的私有成员函数不能用对象访问
四、初始化列表的初始化顺序与变量声明的顺序一致，而不是按照出现在初始化列表中的顺序，这里成员i比成员j先声明，因此正确的顺序是先用j对i进行初始化，然后用2对j初始化，由于在对i进行初始化时，j值为随机值，所以i也是随机值，然后用2对j进行初始化，j的值为2
#include
using namespace std;
 class Obj
 {
 public:
  Obj(int k):j(k),i(j)
{


} 
void print(void)
{
cout< }
private:
int i;
int j;
  /* data */
 };
 int main(int argc, char const *argv[])
{
Obj obj(2);
obj.print();
return 0;
}
五、静态成员时一个类的全局变量，对于非静态成员，每个类对象都有自己的复制品，而静态成员对每个类的类型只有一个复制品，静态成员只有一份，该类类型的所有对象共享访问。
#include
using namespace std;
class Myclass
{
public:
Myclass(int a, int b, int c);
void GetNumber();
void GetSum();
private:
int A;
int B;
int C;
int Num;
static int Sum;


};


int Myclass::Sum = 0;


Myclass::Myclass(int a, int b, int c)
{
A = a;
B = b;
C = c;
Num = A+B+C;
Sum = A+B+C;
}


void Myclass::GetNumber()
{
cout<<"Number = "<
void Myclass::GetSum()
{
cout<<"Sum = "< {
Myclass M(3,7,10),N(14,9,11);
M.GetNumber();
N.GetNumber();
M.GetSum();
N.GetSum();
}
六、和全局对象相比，使用静态数据成员有什么好处
1.静态数据成员没有进入程序的全局名字空间，因此不存在程序中其他全局名字的冲突的可能
2.使用静态数据成员可以隐藏信息，因为静态成员可以是private成员，而全局对象不能
七、有几种情况只能使用初始化列表，不能使用赋值，当类中含有const、reference成员变量和基类的构造函数时都需要初始化列表

使用构造函数初始化列表初始化数据成员，没有定义初始化列表的构造函数体重对数据成员赋值。
对于const和reference类型成员变量，它们只能够被初始化而不能做赋值操作，因此只能用初始化列表
类的构造函数需要调用其积累的构造函数的时候，以下代码可以解释，如果在子类的构造函数中需要初始化父类的private成员，直接对其赋值是不行的，只能调用父类的构造函数才能完成对它的初始化。但在函数体内调用父类的构造函数是不合法的，只能采用初始化列表调用子类构造函数的方式

#include
using namespace std;
class A
{
private:
int a;
public:
A(){}
A(int x):a(x) {}
void printA()
{
cout<<"a = "<

class B : public a
{
private:
int b;
public:
B(int x, int y): A(x)
{
//a=x;    //a为private，无法再子类中被访问，编译错误
//A(x);   //调用方式错误，编译错误
b=y;
}
voud printB()
{
cout<< "b = "<

int main()
{
B b(2,3);
b.printA();   //调用子类的printA
b.printB();  //调用自己的printB
return 0；
}

八、静态成员函数访问
九、全局对象的构造函数会在main函数之前执行
十、c++的空类会产生哪些成员函数
    1、默认构造函数和赋值构造函数，他们被用于类的对象的构建过程
    2、析构函数，他被用于类的对象的析构过程
    3、赋值函数，他被用于同类的对象间的赋值过程
    4、当对类的对象进行取地址&时，此函数被调用