c++学习之路3

• 1.代码区：存放二进制的机器指令，代码区的特点，共享和只读
• 2.全局区：全局变量和静态变量存放在此，还包括常量区：字符串常量和其它常量也存放在于此
• 3.栈区：形参和局部变量
• 4.指针

1) int * p = new int (10);

手动删除 delete p;

2) int * array = new int [10];//创建10个元素

手动删除delete[] array;

• 5.引用--别名

//数据类型 &别名 = 原名

int a = 10;

int &b = a;

//b和a都是指向a的内存地址。

1）引用必须初始化

2）引用在初始化后，不可以改变

• 6.函数的参数传递

1）值传递

void swap1(int a,int b){};

int a =10;

int b =20;

swap1(a,b);

2)地址传递

void swap2(int *a,int *b){}

int a =10;

int b =20;

swap2(&a,&b);

3)引用传递

void swap3(int &a,int &b){}

int a =10;

int b =20;

swap3(a,b);

• 7.占位参数

void func(int a,int){

cout << "this is func" << endl;

}

func(10,10);

void func1(int a,int =10){

cout <<"this is func1"<<endl;

}

func1(10);

• 8.封装

意义：将属性和行为作为一个整体，表现生活中的事物

将属性和行为加以权限控制

public        成员        类内可以访问        类外可以访问

private        成员        类内可以访问        类外不可以访问

protected        成员        类内可以访问        类外不可以访问 

class Person{

public:

        string name;

protected:

        int car;

private:

        int password;

public:

        void func(){

        }

}

• 9.struc 和class区别

class 默认权限为私有

struct 默认权限为公共

• 10.类的理解

其实创建一个类，就是去指定一套规则，人类，就是每个人都有人的属性，方法，比如性别，两条腿，一双手，一个脑袋，不同的是，每个人的外在表现不一样，这些每个人的脑袋聪明程度不一样，身高不一样，体重都一样。类只是去指定一套标准，每个人都有这些，但是表现出来的又不一样的准则。龙生九子，各有不同，都是龙的类，但是外貌，形状都各不同。

在另一个文件中，获取另一个类的属性、方法

1)

Point::getX(){

}

2)

#include "point.h"

防止头文件重复包含

#pragma once

shift+tab 整体缩进

tab 整体往后空格

• 11.拷贝构造函数

class Person{

public:

        Person(){

        cout<<"Person的无参构造函数调用"<<endl;

}

        Person(int a){

        age = a;

        cout<<"Person的有参构造函数调用"<<endl;

}

        Person(const Person &p){//拷贝构造函数

        age = p.age;//将传入的人的身上的所有属性，拷贝到我身上

}

        ~Person(){

        cout<<"Personde 析构造函数调用"<<endl;

}

}

• 12.调用有参构造函数的三种方法

1）括号法：

Person p1(10);

2)显示法：

Person p2 = Person(10);

Person p3 = Person(p2);

3)隐式转换法

Person p4 = 10;//Person p4 = Person(10);

Person p5 = p4;//Person p5 = Person(p4);

//注意：不能利用拷贝函数，初始化匿名对象，编译器会认为是对象声明

//Person p5(p4);

//void p5(p4);

• 13.构造函数调用规则

1）如果用户定义有参构造函数，c++不在提供无参构造，但是会提供拷贝构造函数

2）如果用户定义拷贝构造函数，c++不会再提供其他构造函数

• 14.深拷贝和浅拷贝

浅拷贝：简单的赋值拷贝操作

深拷贝：在地区重新申请空间，进行拷贝操作

例如：

public:

int m_Age ;

int * m_Height;

Person(const Person &p){

  m_Age =  p.m_Age;

  //浅拷贝

  m_Height = p.Height;

  //深拷贝

  m_Height = new int (*p.Height);

}

注意：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

• 15.初始化列表

//传统的赋值

Person (int a,int b,int c){

  m_A = a;

  m_B = b;

  m_C = c;

}

//初始化列表赋值

Person(int a,int b,int c):m_A(a),m_B(b),m_C(c){

}

void test(){

Person p(10,20,30);

cout <<"m_A: "<<p.m_A;

cout <<"m_B: "<<p.m_B;

cout <<"m_C: "<<p.m_C;

}

• 16.静态成员函数

所有对象共享同一个函数

静态成员函数只能访问静态成员变量

注意：静态成员变量在类中仅仅是声明，没有定义，所以在类的外面定义

实际是给静态成员变量分配内存

• 17.this指针

返回类型为引用，return 解引用,才能返回本体

Person{

        Persons(int age){

        this->age = age;

        }

//如果返回类型不加引用&,系统会新建一个对象执行下去，然后不是原来的对象一直链式下去

        Person&  personAddAge(Person &p){

        this->age += p.age;

        return *this;

        }

};

void test2(){

        Person p1(10);

        Person p2(10);

        p2.personAddAge(p1).personAddAge(p1).personAddAge(p1);

        cout<<"p2的年龄为："<<p2.age<<endl;

}

• 18.常函数

成员函数后加const称为常函数

常函数内不可以修改成员属性

但是加了mutable后，在常函数中依然可以修改

常对象：

声明对象前加const称为常对象

常对象只能调用常函数

Person{

public:

        //this指针的本质 是指针常量

        //const Person * const this

        //在成员函数后面加const，修饰的是this指向，让指针的值也不可以修改

        //常函数： 

        void showPerson() const{

        //this->m_A = 100;

        this->m_B = 100;

        //若加了mutable 则可以在常函数中修改变量

        }

        int m_A;

        //特殊变量

        mutable int m_B;

}

void test1(){

        const Person p;//常对象

        //不可以修改       

        //p.m_A = 100;

        //加了mutable 可修改

        //p.m_B = 100;

        //常对象只能调用常函数

        p.showPerson();

}

• 19.友元函数

用来修饰成员函数、类、全局函数，让其可以访问私有的属性和方法

friend xxx;

• 20.运算符重载

class Person{

public :

        //成员函数重载

        Person operator+(Person &p){

        Person temp;

        temp.m_A = this->m_A + p.m_A;

        temp.m_B = this->m_B + p.m_B;

        return temp;        

}

int m_A;

int m_B;

};

//全局函数重载+号

Person operator+(Person &p1,Person &p2){

        Person temp;

        temp.m_A = p1.m_A + p2.m_A;

        temp.m_B = p1.m_B + p2.m_B;

        return temp;        

}

void test(){

        Person p1 ;

        p1.m_A=10;

        p1.m_B=10;

        Person p2;

        p2.m_A=10;

        p2.m_B=10;

        Person p3 = p1+p2;

        //Person p3 = p1.operator+(p2);

        //Person p3 = operator+(p1,p2);

        cout <<"p3.m_A"<<p3.m_A<<endl;

        cout <<"p3.m_B"<<p3.m_B<<endl;

}

左移运算符重载

需求

cout<<p；

就能输出p的所有属性，例如，p.m_A = 10,p._B=10;

用局部成员函数不行，因为

Person(){

void operator<<(ostream sout){

//p.operator<<(sout) == p<<sout

}

}

可以使用全局成员函数

void operator<<(ostream &sout ,Person &p){

//相当于operator(sout ,p)  == cout <<p

sout << p.m_A<<" "  <<p.m_B;

}