C与C++的关系

1.C++可以与C代码进行混编（C++里能写C代码，C里不能写C++代码）
2.C++面向对象编程语言、C面向过程的编程
3.C++对C的一个增强

区别

1.C++多一个数据类型bool
2.三木运算符可以成为左值，被直接赋值

标准命名空间（包含很多标准定义 std::）

也可以使用using namespace std;就不用写std::了。

自定义命名空间

//命名空间提供了更小范围的作用域
namespace NSP_A
{
    int a = 9;
}
namespace NSP_B
{
    int a = 12;
    //命名空间嵌套
    namespace NSP_C
    {
        struct  Teacher
        {
            char name[20];
            int age;
        };
    }
}
void main()
{
    //使用命名空间
    using namespace NSP_A;
    using namespace NSP_B;
    cout << NSP_A::a << endl;
    cout << NSP_B::a << endl;
    //system.out.println() line
    using NSP_B::NSP_C::Teacher;
    Teacher t1;
    t1.age = 12;
    system("pause");
}

类

普通属性与结构体相同的内存布局，静态属性存在全局里面，方法存在程序代码区，并不参与类的大小计算

//圆
class MyCircle
{
private:(共用权限访问修饰符)
    //半径
    double m_r;
    //面积
    double m_s;

public:
    //设置半径
    void setR(double r)
    {
        m_r = r;        
    }
    //获取圆的面积
    double getS()
    {
        m_s = PI * m_r * m_r;
        return m_s;
    }
};

void main()
{
    MyCircle c1;
    c1.setR(4);
    cout<<"圆的面积："<<c1.getS()<<endl;
    system("pause");
}

结构体

struct MyTeacher{
public:
    char name[20];
    int age;
public:
    void say(){
        cout << this->age << "岁" << endl;
    }
};
void main(){
    MyTeacher t1;
    t1.age = 10;
    t1.say();
    system("pause");
}

引用

引用必须要有值，不能为空，引用是变量的别名，指针保存的是变量的地址
1.单纯给变量取别名没有任何意义，作为函数参数传递，能保证参数传递过程中不产生副本
2.引用可以直接操作变量，指针要通过取值(*p)，间接操作变量，指针的可读性差

引用的主要功能：

1.作为函数的参数或返回值

void main(){
    //变量名-门牌号(内存空间0x00001的别名，可以有多个名字)
    int a = 10;
    //b就这个内存空间另外一个别名\
    //& C++中的引用
    int &b = a; 
    cout << b << endl;

    system("pause");
}

2.指针的引用，代替二级指针

void getTeacher(Teacher **p){
    Teacher *tmp = (Teacher*)malloc(sizeof(Teacher));
    tmp->age = 20;
    *p = tmp;
}

//指针的引用，代替二级指针
//Teacher* &p = (Teacher * *p)
void getTeacher(Teacher* &p){
    p = (Teacher*)malloc(sizeof(Teacher));
    p->age = 20;
}

void main(){
    Teacher *t = NULL;

    getTeacher(&t);

    system("pause");
}

指针常量与常量指针

//指针常量，指针的常量，不改变地址的指针，但是可以修改它指向的内容
    int a = 2, b = 3;
    int *const p1 = &a;
    //p1 = &b;  //NO
    *p1 = 4;

    //常量指针，指向常量的指针，内容不能修改
    const int *p2 = &a;
    p2 = &b;
    //*p2 = 9;  //NO

静态属性

静态属性初始化赋值必须是全局的
int Teacher::total = 9;
静态方法里不能访问非静态属性

this指针

当前对象的指针
函数是共享的，必须要有能够标识当前对象是谁的办法

class Teacher{
private:
    char* name;
    int age;
public:
    Teacher(char* name,int age){
        this->name = name;
        this->age = age;
        cout << "Teacher有参构造函数" << endl;
    }
    ~Teacher(){
        cout << "Teacher析构函数" << endl;
    }
    //常函数，修饰的是this
    //既不能改变指针的值，又不能改变指针指向的内容
    //const Teacher* const this
    void myprint() const{
        printf("%#x\n",this);
        //改变属性的值
        //this->name = "yuehang";
        //改变this指针的值
        //this = (Teacher*)0x00009;
        cout << this->name << "," << this->age << endl;
    }
    void myprint2(){        
        cout << this->name << "," << this->age << endl;     
    }
};

void main(){
    Teacher t1("jack",20);
    const Teacher t2("rose", 18);
    //t2.myprint2(); 常量对象只能调用常量函数，不能调用非常量函数
    //常函数，当前对象不能被修改，防止数据成员被非法访问
    printf("%#x\n", &t1);
    t1.myprint();
    printf("%#x\n", &t2);
    t2.myprint();
    system("pause");
}