C++(二)

对C++(一)的回顾：
1.引用的性质四点：成为一个变量的引用就不能成为其他变量的引用，必须有初始值，初始化的内容为常引用要定义为常引用，如果定义为常引用就不能直接改变变量的值但是通过变量可以间接改变引用的值。
2。引用的应用:引用作为参数，不需要给参数开辟空间，也没有产生副本，提高了效率。
3.c++赋值：int b(100);强制转换：int d( c );
4.s.length//字符串长度 for each简便循环打印每个字符。
5.内联函数：inline
6.函数重载：可以根据参数的不同(长度，和类型)区分具体调用哪个函数
7.函数的默认值: 生命和定义只能一个位置加默认值，向后原则，函数重载不能和默认值一块用，会产生二义性
8.哑元函数：参数只有类型，但没有名字，用于扩展
9.封装：private
10.构造函数：构造函数默认值，构造重载，初始化列表
11.析构函数：对象程序执行结束自动调用，堆区创建的对象需要delete
12.作用域限定符：类内声明，类外定义
13.explicit修饰构造函数，屏蔽隐性调用，防止误操作
14.拷贝构造函数：深拷贝，浅拷贝。

接下来我们要记录新学习的内容

this指针

概念

this是c++中的一个关键字，也是const指针，它指向当前对象，通过它可以访问当前对象所有成员。
所谓的当前对象，是指正在使用的对象。例如对于stu.show();,stu就是当前对象，this就指向stu。
更加详细的：http://c.biancheng.net/view/2226.html

作用

主要用于保证访问不能跨界和用于区分不同的对象。成员函数对成员变量的引用实际是通过this指针访问的，也就是说：成员变量this->成员变量；另外，如果成员函数访问当前对象，也可以通过this指针，*this就是当前对象。

指针应用

指针的应用一

当参数和属性重名时，用this指针进行区分。

#include <iostream>
#include <string.h>
using namespace std;
class Test{
private:
    string str1;
    string str2;
public:
    Test(string str1,string str2){
        this->str1=str1;
        this->str2=str2;
    }
};
int main()
{
    Test t("1","2");
}

指针的应用二

函数返回值时类的引用的时候，需要返回*this。

class Value{
private:
    int value=1;
public:
    Value & add(int i){
        value+=i;
        cout<<this<<endl; 	//地址都是一样的
        return *this; 		//*this是当前对象
    }
};

int main()
{
    Value v;
	v.add(1);
}

static

概念

是一个关键字，可以用来修饰变量，还可以用来修饰函数，在使用static关键字修饰变量时，我们称此为静态变量。

作用

1.在函数体内，静态变量具有记忆作用，即一个被声明为静态的变量在这一函数被调用的过程中其值维持不变。
例子：

void fun()
{
a++;
cout<<a<<endl;
}
int main(){
fun();
fun();
}

当第一次调用时为1，第二次调用在一的基础上加加

2.在函数体外，定义在全局，每个成员函数都可以访问。(像全局变量的意思)
例子：

#include <iostream>
using namespace std;
static int a;
void static fun()
{
    a++;
    cout<<a<<" ";
}
void fun1()
{
    a++;
    cout<<a<<" ";
}
int main()
{
    fun();
    fun1();
    fun();
    fun1();
    return 0;
}

打印结果为1 2 3 4 ,也有记忆功能

3.在类内，定义成员变量，类外不可以访问，类内的各个函数可以访问
例子：

#include <iostream>
using namespace std;
class Per{
public:
    static int a;
};
class son:public Per{
public:
    void fun()
    {
        cout<<a<<endl;  //错误
    }
};

int main()
{
    son s;
    s.fun();
    return 0;
}

报错，不可以访问父类的静态成员。

4.在类中，static 除了可以声明静态成员变量，还可以声明静态成员函数。普通成员函数可以访问所有成员（包括成员变量和成员函数），静态成员函数只能访问静态成员。
例子：

class Per{
private:
    int a;
    static int b;
public:
    void fun()
    {
        cout<<a<<" "<<b<<endl;
    }
    static void fun1()
    {
        cout<<a<<" "<<b<<endl;
    }
};

int main()
{
    Per p;
    p.fun();
    p.fun1();
    return 0;
}

报错，静态成员函数只能访问静态成员和静态函数

特点

静态成员变量：此类中所有的对象都共享此变量。非const的静态成员变量必须类里面声明，在类外初始化。程序运行时创建，程序结束时销毁。
如何初始化？
数据类型 类名：：变量名=？
int Per::a=1;
静态函数：静态成员函数不能访问类中的非静态变量。静态成员函数不能访问类中的非静态函数，反过来可以。如果静态成员函数声明与定义分离的时候，只需要在声明处使用static关键字。
静态成员函数与普通成员函数的根本区别在于：普通成员函数有 this 指针，可以访问类中的任意成员；而静态成员函数没有 this 指针，只能访问静态成员（包括静态成员变量和静态成员函数）。
具体的说明见：http://c.biancheng.net/view/2228.html

const关键字

const表示常量的意思，意味着运行的时候其修饰的内容不可以该。

常成员函数

概念：常成员函数就是在函数上加const关键字
特点：
可以访问非const成员属性，但不能更改其值
常成员函数也不能访问非const成员函数
例子：

class Test{
private:
    int a=1;
public:
    void get_a() const{
        //a++;错误
        cout<<a<<endl;
    }
    void set_a(){
        a++;
    }
    void method() const
    {
        cout<<a<<endl;
        //a++; 不能修改
        //set_a(); 错误
			 //get_a(); 错误
    }
};

常量对象

概念：const修饰的对象
特点：
常对象可以访问属性，但不能修改其值
常对象不能调用非const的成员函数
例子：

class Test{
private:
    int a=1;
public:
    void get_a() const{
        cout<<a<<endl;
    }
    void set_a(){
        a++;
    }
};
int main()
{
    Test const t;
    t.get_a();
    //t.set_a(); 错误
    const Test t2;		//const也可以放在Test前
}

常成员变量

概念：const修饰的成员变量，就是常成员变量
特点：
运行时常成员变量的值不可改
对它进行初始化，要么定义的时候直接初始化。或者构造函数初始化列表赋值
例子：

#include <iostream>
using namespace std;
class Test{
private:
    int a=1;
    const int b;
    const int c=4;//1.直接赋值
public:
//    Test(int a, int b){ //不能对b赋值
//        this->a=a;
//        this->b=b;
//    }
    //2.需要构造初始化列表来赋值
    Test(int a,int b):a(a),b(b=2){}
    void get_a() const{
        cout<<a<<endl;
        cout<<b<<endl;
        cout<<c<<endl;
    }
    void set_a(){
        a++;
    }
};
int main()
{
    Test t(2,3);
    t.get_a();
}

const修饰局部变量

特点：给局部变量如参数加const修饰。函数参数值是2不可以更改的。
例子：

void func(const int b){
        //b++; 错误
        cout<<b<<endl;
        const int c=10;
        //c++; 错误
        cout<<c<<endl;
    }

面向对象基础告一段落，别把static与const搞混了！！