c++基本学习_01

学完c然后学c++基本语法,开始还是会有一些转变不过来

#pragma once表示只导入一次头文件

new关键字的使用,需要在堆内存分配内存的时候使用,和c的动态分配内存相同,使用完手动调用delete(void *);

命名空间(name namespace)

使用：
//这里代表使用命名空间和java导包有点类似
using namespace std;
//导入后可以这样使用
cout << "这是命名空间" << endl;
//未导入命名空间
std::cout << "name is joker" << std::endl;
作用域符号::的前面一般是类名称,后面一般是该类的成员名称
再来一个自己定义的列子:
//定义一个命名空间
1.不导入
namespace TSIMEON {
    void name() {
        std::cout << "name is tsimeon" << std::endl;
    }
}
int main() {
    //使用
    TSIMEON::name();
}
2.导入
using namespace TSIMEON;
int main() {
    //使用
    name();
}

类(关键字class)

修饰符[默认是private]这一点和java有所不同

• public

• private

• protected

  使用:

Student.h

#ifndef JNIWORK_STUDENT_H
#include <iostream>
using namespace std;
#define JNIWORK_STUDENT_H

class Student {
    //享元函数
    friend void changeAge(Student *);

    friend class Teacher;

    //默认是private
    string name;
    int age;
public:
    //构造函数
    Student();

    //构造函数
    Student(string name, int age);

    //析构函数
    ~Student();

    string getName() {
        return this->name;
    }

    int getAge() {
        return this->age;
    }

private:
    bool sex;

};


class Teacher {
public:
    void modifyStu(Student *stu) {
        stu->name = "班主任:名字给你改了";
    }

};

#endif //JNIWORK_STUDENT_H

Student.cpp

#include "Student.h"
#include <iostream>

using namespace std;

Student::Student() {
    cout << "无参构造函数" << endl;
}

Student::Student(string name, int age) : name(name), age(age) {
    cout << "有参数构造函数" << endl;
}

Student::~Student() {
    //释放内存的时候自动调用_可以做一些收尾的工作
    cout << "析构函数" << endl;
}

//运行函数
int main() {

    Student *student = new Student("tsimeon", 29);
    cout << student->getName() << endl;
    changeAge(student);
    cout << "改变后的名字:" << student->getName() << endl;
    Teacher teacher;
    //修改学生的名字
    teacher.modifyStu(student);
    cout << "老师修改后的名字:" << student->getName() << endl;
    //释放
    delete (student);
    student = 0;
}
理解：享元类和享元函数可以访问私有的变量。析构函数是释放内存的时候自动调用_可以做一些收尾的工作

单列和java类似(保证构造方法私有化)

Instance.h

#ifndef JNIWORK_INSTANCE_H
#define JNIWORK_INSTANCE_H

//单列
class Instance {
private:
    static Instance *instance;

    //构造方法私有化
    Instance();

public:
    static Instance *getInstance();
};


#endif //JNIWORK_INSTANCE_H

Instance.cpp

#include "Instance.h"

//构造方法
Instance::Instance() {

}

Instance *Instance::getInstance() {
    //c++11  编译器 保证内部静态变量 的线程安全
    if (!instance) {
        instance = new Instance();
    }
    return instance;
}

使用:

int main() {
    Instance *instance = Instance::getInstance();
}

运算符重载

可以重定义或重载大部分 C++ 内置的运算符。
重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的

1.成员函数写法
Operator.h

//运算符重载
#ifndef JNIWORK_OPERATOR_H
#define JNIWORK_OPERATOR_H
#pragma once

#include <iostream>

using namespace std;

class Operator1 {
public:
    int i = 0;

    Operator1() {

    }

    //成员函数运算符重载
    Operator1 *operator+(const Operator1 &t) {
        Operator1 *temp = new Operator1();
        temp->i = this->i + t.i;
        return temp;
    }
};


#endif //JNIWORK_OPERATOR_H

使用：

int main() {
    Operator1 op0;
    op0.i = 100;
    Operator1 op1;
    op1.i = 100;
    //Operator1* operator2 = op0.operator+(op1);这句话相当于下面这句,运算符重载
    Operator1 *operator2 = op0 + (op1);
    cout << operator2->i << endl;
     //输出值是200
    return 0;
}

2.普通写法

//运算符重载
int operator+(const Operator1 &t1, const Operator1 &t2) {
    return t1.i + t2.i;
}

int main() {
    Operator1 op0;
    op0.i = 100;

    Operator1 op2;
    op2.i = 100;
    //Operator1* operator1 = op0.operator+(op2);这句话相当于下面这句,运算符重载
    int value = op0 + (op2);
    cout << value << endl;
    //输出值依然是200
    return 0;
}