构造函数。。

// 使用new关键字，实例化对象
    Student *str = new Student;
    // 设置对象的数据成员
    str->setName("慕课网");
    // 使用cout打印对象str的数据成员
    cout << str->getName() <<endl;
    // 将对象str的内存释放，并将其置空
    delete str;
    str = NULL;
    return 0;

1. 不要漏掉str->getName()后的  ()  ;
   

2. str 是 Student 类型的，所以申请的内存类型也是 Student ；

3. str 是 Student 类型而非 数组 ，所以不可以用 delete []str ;
   

string

当初始化的数据为const类型的时候，初始化列表存在就很有必要性

类内定义与内联函数：

关于内联函数：

关键字：inline

#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;
//数据成员命名规则：m_数据类型+名字,这样看到就知道它是定义在类里面的数据成员了
class Student{
public:
void setName(string _name){
m_strName = _name;
}
string getName(){
return m_strName;
}
void setGender(string _gender){
m_strGender = _gender;
}
string getGender(){
return m_strGender;
}
int getScore(){
return m_iScore;
}
void initScore(){
m_iScore = 0;
}
void study(int _score){
m_iScore += _score;
}
private:
string m_strName;
string m_strGender;
int m_iScore;
}
int main(){
//实例化累的对象
Student stu;
stu.initScore();//需要初始化
stu.setName("zhangsan");
stu.setGender("女");
stu.study(5);
stu.study(3);
cout<<stu.getName()<<" "<<stu.getGender()<<" "<<stu.getScore()<<endl;
return 0;
}

上例违背了面向对象的思想。

面向对象的基本思想：

封装的好处：

希望成员变量只能被外界读取，而不被外界改变：

#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;



int main(){
    string name;
    cout<<"Please input your name:";
    //不能简单使用cin，因为要判断是否为空
    getline(cin,name);//若输入的是一个空串，则给cin空串若非空，也给cin
    if(name.empty()){//是回车
        cout<<"input is null.."<<endl;
        system("pause");
        return 0;
    }
    //字符串的对比
    if(name == "imooc"){
        cout<<"you are a administrator"<<endl;
    }
    //注意理解记忆
    cout<<"hello"+name<<endl;
    //cout<<"your name length:"+name.size()<<endl;
    //有问题是因为前为字符串后不为字符串，连接不能用+，用<<
    cout<<"your name length:"<<name.size()<<endl;
    cout<<"your name first letter is:"<<name[0]<<endl;//因为name[0]是一个char不用用+号

    return 0;
}

可以不再使用众多str的函数。需要注意s1+s2.

#include <iostream>
#include <stdlib.h>
using namespace std;

class Coordinate{
public:
    int x;
    int y;
    void printX(){
        cout<<x<<endl;
    }
    void printY(){
        cout<<y<<endl;
    }
};

int main(){
    //在栈中定一个对象
    Coordinate coor;
    coor.x = 10;
    coor.y = 20;
    coor.printX();
    coor.printY();

    //在堆中实例化一个对象
    Coordinate *p = new Coordinate();
    //容易忘记判断
    if(NULL == p){
        //failed;
        return 0;
    }
    p->x = 30;
    p->y = 40;
    p->printX();
    p->printY();
    //容易忘
    delete p;
    p = NULL;
    system("pause");
    return 0;
}

对象成员的访问：

分为通过栈、堆实例化对象（下例是单一对象）：

若是对象数组：

对象实例化，类是一个模板

实例化类有两种方式：从栈实例化、从堆实例化

从栈实例化：

从堆中实例化：

int main(){
    TV *p = new TV();//new运算符申请出来的运算符就是在堆上
    TV *q = new TV[20];
    //todo
    delete p;
    delete []q;
    return 0;
}

如何把想显示的东西暴露，把想隐藏的东西隐藏：访问限定符

对象是具体的事物，而类是从多个对象中抽象出来的。

字符串的常用操作