一、类和对象#

1. 类#

  1. 类是构成对象的一个蓝图
  2. 可以拥于属性（用于表示数据）
  3. 可以拥有方法 ( 用于表示行为动作 )
  4. 可以隐藏数据和方法
  5. 可以对外提供公开的接口
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
#include<string>

using namespace std;

class Student{
private:
    string name;   // 姓名
    int age;  //年龄

public:
    void read(){
        std::cout << "学生在看书" << std::endl;
    }
};

2. 对象#

1. 在栈中创建对象#

用这种方法创建的对象，内存分配到栈里（Stack）。 直接使用 . 来访问成员。当程序对象所在的代码块结束运行（方法运行结束），对象会自动删除，内存自动释放。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
class student{
    ...

}

int main(){
    //对象存储于栈内存中
    student stu1 ;
    student stu2 ;

    return 0 ;
}

2. 在堆中创建对象#

这种方法创建的对象，内存分配到堆里（Heap）。一般使用* 或者 -> 调用对象的方法。箭头操作符”->"将解引用（dereferencing*）和成员使用（member access.）结合起来，

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include<iostream>
#include<string>

using namespace std;

class student{
public:
    void run(){
        cout << "学生在跑步" << endl;
    }

}

int main(){
    //对象存储于栈内存中 new 关键字是在堆中申请动态内存，所以这里不能写成 s3 而应该是指针。

    Student *s3 = new Student;
    s3->run();

    *s3.run();
    return 0 ;
}

3. 访问修饰符#

python中修饰成员访问权限，采用的是下划线的形态来修饰。

c++ 对于成员的访问有三种访问操作符 public | prive | protected ， 默认情况下是private

  1. public : 公开权限，任何位置都可以访问
  2. private : 私有权限，只能自己内部访问及其友元函数
  3. protected : 类内、子类及友元函数可访问
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
#include<iostream>
#include<string>

using namespace std;

class Student{
    private: //表示下面的成员为私有
      string name;   // 姓名
      int age;  //年龄

    public: //表示下面的函数为公开
        void run(){}
};

ing main(){
    Student stu ;

    stu.name = "张三" ; // 禁止访问
    stu.run(); //允许访问
    return 0 ;
}

4. 实现类的成员函数#

1. 类中实现 或 外部实现#

  1. 成员函数可以在类中声明时直接实现，也可以在类的外部。
  2. 可以在类的外部实现成员你函数 ， 需要使用 类名::函数名
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <iostream>
#include <string>

using namespace std;

class Student{

    private :
        int age ;
        string name;

    public :
        void read(string bookname){
            cout<< bookname << endl;
        }

       void speak(string something);
}


void Student::speak(string something){
    cout << "说说说---" << something << endl;
}

int main(){

    Student stu;

    stu.read("哈利波特");
    stu.speak("我喜欢看哈利波特");

    return 0 ;

}

2. 分离声明和实现#

声明放到 头文件中，实现放到cpp文件中 。 头文件的声明，需要在前后包裹一段特殊的样式代码。这段代码确保了一旦该头文件多次包含执行时，出现重复定义的错误。

如下所示： 当第一次包含 Student.h时，由于没有定义 _STUDENT_H_，条件为真，这样就会包含（执行）#ifndef _STUDENT_H_和#endif 之间的代码，当第二次包含Student.h时前面一次已经定义了_STUDENT_H_，条件为假，#ifndef_STUDENT_H_和#endif之间的代码也就不会再次被包含，这样就避免了重定义了。

  • Student.h
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
//后面的大写表示标识，可以随意命名.
#ifndef HELLOWORLD_STUDENT_H
#define HELLOWORLD_STUDENT_H

#include <string>
using namespace std;

class Student{

private :
    int age ;
    string name;

public :
    void read(string bookname);

    void speak(string something);
};


#endif //HELLOWORLD2_STUDENT_H
  • Student.cpp
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
#include "student.h"

#include <iostream>
using namespace std;

void Student::read(string bookname){
cout << "看书："<<bookname<<endl;
}

void Student::speak(string something){
cout << "说说说---" << something << endl;
}
  • main.cpp
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
#include <iostream>
#include "student.h"

int main() {

    Student s;
    s.read("哈利波特");
    s.speak("hi harry");

    return 0;
}
  • CMakeList.txt
1
2
3
4
5
6
7
cmake_minimum_required(VERSION 3.14)
project(HelloWorld2)

set(CMAKE_CXX_STANDARD 14)

# 需要在后面添加student.cpp 因为main.cpp 依赖该文件
add_executable(HelloWorld main.cpp student.cpp)