C++：数据类型

1 C++

  1.1 什么是C++语言呢？

    C++语言是面向过程编程的高级语言， 同时也可以向高级语言一样面向对象编程，泛型编程；

    C++语言派生自C语言，所以C++语言可以向下兼容C语言；C++相比C，扩展了面向对象编程，泛型编程；

    C++语言大小写敏感，支持ANSI标准；

    G++编译器是将 gcc 默认语言设为 C++ 的一个特殊的版本；如果命名遵循规范，那么通过gcc来编译c++也是可行的；

  1.2 C++面向对象的特性

    1.2.1 封装 Encapsulation：将程序打包封装成接口，隐藏实现细节，只对外提供调用接口；

    1.2.2 继承 Inheritance：  从已有类中派生出新类，新类具有已有类的属性和方法，并且可以扩展或修改这些属性和方法；

    1.2.3 多态 Polymorphism：同一种操作作用于不同的对象，可以有不同的解释和实现。它可以通过接口或继承实现，可以提高代码的灵活性和可读性；

    1.2.4 抽象 Abstraction：  从具体的实例中提取共同的特征，形成抽象类或接口，以便于代码的复用和扩展；

  1.3 C++语言分布

    1.3.1 基础数据结构：              变量，数据类型，常量等；    用于构造数据类；

    1.3.2 C++标准库：                 C++标准库函数；                 用于操作文件，字符串等；

    1.3.3 C++标准模板库(STL)：  C++标准库方法函数；           用于操作数据结构等；

2 C++基本语法

  2.1 数据类型转换 cast

    2.1.1 静态转换 static_cast：         用于将一种数据类型的值 转换为 另一种相似的数据类型的值；

                       转换时不进行类型检查，因此可能会引发异常；

    2.1.2 动态转换 dynamic_cast：    用于将基类指针或引用 转换为 派生类指针或引用；

                       转换时会进行类型检查，如果不能进行转换则返回空指针或引发异常；

    2.1.3 常量转换 const_cast：         用于将const类型的对象属性 转换为 非const类型的对象属性；

    2.1.4 重新解释转换reinterpret_cast：用于将一种数据类型的值 转换为 另一种数据类型的值；

                     转换时不进行类型检查，因此可能会引发异常；

int i = 10;
float f = static_cast<float>(i); // 静态将int类型转换为float类型
 
class Base {};
class Derived : public Base {};
Base* ptr_base = new Derived;
Derived* ptr_derived = dynamic_cast<Derived*>(ptr_base); // 将基类指针转换为派生类指针
 
const int i = 10;
int& r = const_cast<int&>(i); // 常量转换，将const int转换为int
 
int i = 10;
float f = reinterpret_cast<float&>(i); // 重新解释将int类型转换为float类型

  2.2 类作用域变量

    声明在类内部的变量，使用类名和作用域解析运算符“::”来访问；

#include <iostream>
class MyClass {
public:
    static int class_var;  // 类作用域变量
};
int MyClass::class_var = 30;
int main() {
    std::cout << "类变量: " << MyClass::class_var << std::endl;
    return 0;
}

  2.3 引用变量

    2.3.1 引用变量声明

      定义：引用其他变量的变量，作用类似指针但不是指针；

      属性：引用变量在创建时必须初始化其被引用对象，引用变量的被引用对象不能修改；不存在空引用；

int    i;
int&    r = i;    //声明引用变量r，i是被引用变量;这样可以通过r，i变量访问同一块内存;

    2.3.2 引用变量作用

      2.3.2.1 作为函数形参传递，传递之后对引用变量的修改就相当于对被引用变量的修改，作用等价于指针，但是更安全；

      2.3.2.2 作为函数返回值传递；注意这里有点反常识但是合理，此时函数可以被放在等式左边用来赋值；

double vals[] = {10.1, 12.6, 33.1, 24.1, 50.0};
double& setValues(int i) {  
   double& ref = vals[i];    // 这里引用声明，传递的是vals[i]的内存，那可不就是地址了嘛;
   return ref;               // 返回引用变量，这样函数就可以被放在等式左边用来赋值了;    
}
 
setValues(1) = 20.23;        // 将20.23存储到 vals[1]了;

 3 类

  类是一种自定义数据类型，可以用来创建具有相同属性和行为的多个对象；是C++的核心特性；

#include<iostream>
using namespace std;
//记录一下我的第一个c++程序,虽然这是一个因为傻吊主管而半途而废的新起点;
class Box{                                      //声明一个类,名字为Box;
    public:                                     //声明类成员的访问属性public;
        double length;                          //声明类变量
        double height;
        void set(double length,double height);   //声明类方法函数
        double get_area(void){                   //函数定义在类内,则默认声明为内联inline函数;
            return length * height;
        }
};
 
    void Box::set(double len, double hei){
	    length = len;
	    height = hei;
    }
 
int main(){
    cout<<"hello c++ \n"<<endl;
    Box box1;
    double area;
 
    box1.set(15,30);
    area = box1.get_area();
    cout<<"box1.get_area:"<< area <<endl;
}

  3.1 类成员 访问修饰符

    一个类内部可以有多种访问修饰符，不写访问修饰符默认为private属性；

    3.1.1 public 公有属性：     在当前类、类的外部也可以访问类内部的公有成员；

    3.1.2 protected 受保护属性： 在当前类、友元函数和派生类中可以访问受保护成员；

    3.1.3 private 私有属性：         在当前类、友元函数可以访问私有成员；派生类不可以访问；

  3.2 派生类 继承属性    

    派生类成员可以继承基类成员的访问属性；private继承，则派生类成员不能访问基类成员；

    3.2.1 public class_A 继承：  基类 public,protected,private成员的访问属性在派生类中分别变成：public, protected, private；

    3.2.2 protected class_A 继承： 基类 public,protected,private成员的访问属性在派生类中分别变成：protected, protected, private；

    3.2.3 private class_A 继承：   基类 public,protected,private成员的访问属性在派生类中分别变成：private, private, private；

  3.3 构造函数

    类的构造函数 会在每次创建新的类对象时执行；

    名称与类完全相同，没有返回类型，可以带参数类型；作用主要是用于为成员变量设置初值；

  3.4 析构函数

    类的析构函数 会在每次删除已创建的类对象时执行；

    名称与类完全相同但是加了一个~，没有返回类型，没有参数类型；作用主要是用来释放资源；

  3.5 拷贝构造函数

  3.6 友元函数

  3.7 内联函数

  3.8 this指针

  3.9 指向类的指针

  3.10 静态成员

 

4 纯虚函数

  声明在基类中的函数；它在基类中没有定义不能实例化，由派生类重新声明后才能实例化；看来主要作用是占位，先放着；

模板

//比如定义的时候是template<class V, class M=void>;
//那等会代码中的类名V就替换掉;代码中的M就替换成void;
 
//比如在在View类中写了 template<class P>
//引用的时候代码为：View<WatchDrainagePresenter>
//表示等下View类中的V都用WatchDrainagePresenter替代了；

  

 

 

上面这几个类型转换里，const_cast<>，reinterpret_cast<>里为什么有& ？？先放着；

引用变量的&号靠近变量放着可以么？先放着；