C++类及使用 概念及易忽略点小结

指定基本类型等价于完成三项工作：

@：决定数据对象需要的内存数量

@：决定如何解释内存中的位（long 和 float 在内存中占用的位相同，但是转换方法却不同）

@：决定可使用数据对象执行的操作或方法

C++ 中的类：

类规范有两个部分组成：

类声明：以数据成员的方式描述数据部分，以成员函数（方法）的方式描述公有接口。

类方法定义：描述如何实现类成员函数。

简单来说，类声明提供了类的蓝图，而方法定义则提供了细节。

将数据与方法组合成一个单元是类最吸引人的特性，类要尽可能的将公有接口与实现细节分开。公有接口表示设计的抽象组件。将实现细节放在一起并将他们与抽象分开被称为封装，将实现细节隐藏在私有部分中，也可以理解为将类函数定义和类声明放在不同的文件中。

控制对成员的访问：

无论类成员是数据成员还是成员函数，都可以在类的公有或私有部分声明它。但是由于隐藏数据是OPP的主要目标之一，因此数据项通常放在私有部分，成员函数（方法）一般放在公有部分，否则无法从程序中调用这些函数。公有成员函数却可以调用私有函数。

类中成员函数的实现：

定义一个类的成员函数，必须给函数名加上"::" 域名解析符。这样就基本能保证函数的作用域式安全的。

一个并不是最佳的但是基本可以说说明问题的类的成员函数：

内联方法：

定义于类声明中的函数都将自动成为内联函数。为此，只需在类实现部分中定义函数时使用inline 限定符即可，注意代码块在类内的函数才会自动成为内联函数，但是如果成员函数在类外，需要加上inline 关键字，但是这只是一种请求，不是所有的情况都可以变成内联函数的。同样的由此可见，既然类内的函数会自动变成内联函数，而不需要通过编译器的仲裁，直接反映了，类很可能就是一种静态的存储方式。同时一般的也把内联函数放在头文件中，也更为方便。

方法使用对象：

首先什么时对象？对象就是类的实例化，比如有一个类的名字叫做CAT；

那么对象的就是：

CAT A，B；

这里A，B 就是对象了。

使用方法简单来说就是调用类中方法与函数 。

比如CAT 这个类中有eat ( )这个函数现在，调用这个函数---》 A.eat( ) ;就算是使用对象中的方法了。

创建类对象，可以声明类变量，也可以使用new 为类对象分配存储空间。也可以将对象作为函数的参数和返回值，也可以讲一个对象赋给另一个。



客户/服务器模型(类比）

OPP程序员一般依照客户/服务器模型来讨论程序设计，客户是使用类的程序。类声明构成了服务器，它是程序可以使用的资源。客户只能通过以公有的接口使用服务器

，根据该接口可靠并且准确的执行。服务器设计人员只能修改类的设计的实现细节，而不能修改接口。这样程序员独立地对客户端服务器进行改进，对服务器的修改不会对客户的行为造成意外的影响。

构造函数与析构函数

构造函数：

专门创建一个新对象，将值赋给他们的数据成员。并且没有声明类型。

构造函数的参数表示的不是类的成员，而是赋给类成员的值。因此类名不能与类成员函数相同。

构造函数的使用方式：

1.定义的构造函数

2.默认构造函数

定义的构造函数就是根据我们的意愿赋值，建造的新对象。

默认构造函数就是操作系统创建新对象的时候，自动给新建对象的变量复赋值。

析构函数：

简单来说就是释放已经使用的资源的函数，它名字比较特殊一般在类的名字前边加上（～）。和构造函数一样，析构函数也可以没有返回值，和声明类型。与构造函数不同的是，析构函数没有参数。

类的赋值：

在默认情况下：将一个对象赋给同类型的另一个对象。C++将源对象的每一个数据成员的内容复制到目标对象中相应的数据成员中。

如果可以通过初始化也可以通过赋值来设置对象的值，应采用初始化的方式，通常这种方式的效率更高。

构造函数与析构函数小结：

构造函数是一类特殊的成员函数，在创建类的时候被使用，构造函数的名称和类相同，但是通过函数重载可以创建多个同名的构造函数，条件是每个函数的特征标识都不同，另外构造函数没有声明类型。通常，构造函数用来初始化类对象成员，初始化应与构造函数的参数列表相匹配。

This 指针：

这个指针指的是调用方法的对象。this 是指向这个对象的指针，并且*this 这个对象。

注意这个指针只能在成员函数中调用。其他类型的方法不能调用这个指针，就算是友元函数也不行；

操作符重载：

简单来说操作符重载就是给一个操作符一个新的使用方式，重载必须要调用一种方法：operator();使用这种方法就可以重载了。比如说重载一个符号使两个类可以相加：

#include<iostream>

class Two{
    private:
        double a;
        double b;
        double sum;
    public:
        Two();
        Two(double one,double two);
        void show()const;
        Two operator+ (const Two & t)const;
        Two operator- (const Two & t)const;
        Two operator* (double n)const;
        friend Two operator* (double a,const Two & t)
        {return t * a; }
        friend std::ostream & operator<< (std::ostream & os,const Two & t);
};

Two::Two(){
    a = 0;
    b = 0;
    sum = 0;
}

Two::Two(double one,double two){
    a = one;
    b = two;
    sum = 0;
}

void Two::show()const{
    std::cout << a << std::endl;
    std::cout << b << std::endl;
    std::cout << "sum = " << sum << std::endl;
}
 
Two Two ::operator+ (const Two &t)const{
    Two temp;
    temp.sum = this->a + this->b + t.a + t.b;
    return temp;
}

Two Two ::operator- (const Two &t)const{
    Two temp;
    temp.sum = this->a - t.a + this->b -t.a;
    return temp;
}

Two Two:: operator* (double n)const{
    Two temp;
    temp.a = this->a * n;
    temp.b = this->b * n;
    temp.sum = temp.a + temp.b;
    return temp;
}

std::ostream & operator<< (std::ostream & os, const Two & t){
    os << "a = "<< t.a << " b = " << t.b << " sum = " << t.sum;
    return os;
}

int main(){
    int a,b;
    std::cin >> a >> b ;
    Two first(a,b);
    Two second(2,2);
    std::cout << first << std::endl;
    int mut = 10;
    first =  second;
    std::cout << first<<std::endl;
}

比如这段代码就展示了重载+ - * 以及 >> 符号。但是特殊的 像 "<< " >>": "~"," =" 这些符号必须使用友元函数重载，不能使用成员函数。

重载限制：

1.重载后的操作数必须有一种是用户自定义类型的

2.使用操作符是尽量不要违反原来的操作符意义

3.不能重新定义操作符

4.这些操作符不能重载：sizeof , . ,* ,:: ,?:,typeid ,const_cast,dynamic_cast,reinterpret_cast ,reinterpret-cast,static_cast.

5.有些操作符只能通过成员函数重载： = ， （）， [ ] , -> .

上名提到了一个新名词友元函数：

简单来说，就是一种函数具有和成员函数一样的访问私有变量的权力，但是又不是成员函数的函数.

创建友元函数：

1。将原型放在类的声明中并且在类型处声明friend

2。不能使用成员操作符，因为它并不是成员函数

3。 特性：与成员函数访问权限相同

4。友元函数和类方法只是表达类接口的两种不同机制。

关于类的强制类型转换问题：

可以根据使用情况，定义相关的类方法或友元函数即可。