C++基础学习第一天

时间 2021-04-01

标签 ios c++ 算法数组函数工具 spa 设计指针 code 栏目 C&C++ 繁體版

原文原文链接

类与对象

struct与class

聚合类

最初的C++称为“带类的C”，扩展了C语言的不少功能。在C++语言中，仍然可使用C语言中的struct定义结构。ios

struct 结构名{
    类型 变量名;
    类型 变量名;
    ...
}

在C++中，聚合类是一种特殊类型的类，用户能够直接访问其成员，而且具备特殊的初始化语法形式（能够提供一对花括号括起来的成员初始值列表初始化聚合类的数据成员）。c++

聚合类应当知足的条件：算法

全部的成员都是public类型的（任何状况下，对象均可以经过成员运算符访问成员）；
没有定义任何构造函数；
没有类内初始值；
没有基类，也没有虚函数。

举个例子，定义一个聚合类Data：数组

struct Data{
    int ival;
    string str;   
};

初始化能够这样：函数

Data dval = {8,"Smith"};

注意：初始值的顺序必须与成员声明的顺序一致。初始值列表中元素的个数若是少于类的成员数量，则靠后的成员被值初始化。初始值列表中元素的个数绝对不能少于类的成员数量。工具

C++对struct的扩展

C++中的struct不只能够包含数据，还能够包含函数。spa

举个例子：设计

#include<iostream>

using namespace std;
struct Complex{
    double real;
    double imag;
    void init(double r,double i){
        real = r;
        imag = i;
    }
    double getReal(){return real;}
    double getImag(){return imag;}
};

int main(){
    Complex c;
    c.init(2,3);
    cout <<c.getReal() <<"+" <<c.getImag() <<"i" <<endl;
    return 0;
}

小提示：在结构中数据成员后面带分号，函数成员后面是不带分号的，可是函数成员内须要带分号，结构反括号后面也是要加分号的，main结束是不加分号的。指针

说明：结构中的数据和函数称为成员，real、imag是数据成员。定义Complex结构后，就能够用它来定义变量，并能经过成员运算符访问它的成员函数。code

访问权限

为了实现信息隐藏，限制对结构中某些成员的非法访问，C++增高了3个访问权限限定符，用于设置结构中数据成员和函数成员的访问权限。

public

被设置为public权限的成员（包括数据成员和函数成员）称为类的公有成员，可被任何函数访问（包括结构内和结构外的函数）。
private

被设置为private权限的成员（包括数据成员和函数成员）称为类的私有成员，仅供结构（类）的内部（自身成员函数）访问。
protected

protected与继承有关。供结构（类）的内部及后代（派生类）访问。

在C和C++中，若是没有声明访问权限，默认的访问权限是public。若是不想让外部直接访问须要加个private声明为私有类型。C++结构的定义形式：

struct 类名{
    [public:]
    	成员;
    private:
    	成员;
    protected:
    	成员;
};

类

类（class）具备信息隐藏的能力，可以完成接口与实现的分离，用于把数据抽象的结果封装成能够用于程序设计的抽象数据类型。是面向对象程序设计中通用的数据封装工具。在C++中，class具备与struct彻底相同的功能，用法一致。类是默认private。

类也是一种自定义数据类型，用关键字class表示，用法与struct相同，形式以下：

class 类名{
    [private:]
    	成员;
    public:
    	成员;
    protected:
    	成员;
};

类名一般首字符大写的标识符表示；一对花括号界定了类的范围；最后的分号必不可少，表示类声明结束。

举个例子：

class Complex
{
    private:
    	double real,imag;
    public:
    	void init(double r,double i){
            real = r;
            imag = i;
        }
    	double getReal(){return real;}
    	double getImag(){return imag;}
    	void print(){
        	cout <<c.getReal() <<"+" <<c.getImag() <<"i" <<endl;
    	}
};

对于类定义须要注意的问题：

访问说明符

对于类声明中的访问说明符private、public和protected没有前后主次之分，也没有使用次数的限制。只是出于信息隐藏的目的，将数据成员设置为private权限，将须要让外部函数访问的成员设置为public权限。
类做用域

class或struct后面的一对花括号包围的区域是一种独立的做用域，称为类域。类域内的数据和函数都称为成员（数据称为数据成员，函数常被称为成员函数）。同一类域内的成员是不爱访问权限和前后次序的限制，相互间能够直接访问。
关键字struct和class

C++的struct也是一种类，它与class具备相同的功能，用法也是彻底相同。惟一区别是在没有指定成员的访问权限时，默认的权限是不同的。

抽象与封装

类是对客观世界中同类事物的抽象，它给出了属于该类事物共有的属性（数据成员）和操做（成员函数）。

类具备封装特性。

可以把数据和算法组合在一块儿，构成一个不可分割的总体；
可以有效地把类的内部数据隐藏起来，外部函数只能经过类的公有成员才能访问类的内部数据。

抽象是对具体对象（问题）进行归纳，抓住问题的本质，抽出这一类对象共有的性质，并加以描述的过程，抽象主要包括数据抽象和过程抽象。

抽象与封装的区别：抽象是一种思惟方式，而封装是一种基于抽象性的操做方法。通常经过抽象，把所获得的数据信息以封装的技术将其从新整合，造成一个新的有机体，这就是类。

类的成员

数据成员

类的数据成员能够是任何数据类型，如整型、浮点型、字符型、数组、指针和引用等，也能够是另一个类的对象或指向对象的指针，还能够是自身类的指针或引用，但不能是自身类的对象；能够是const常量，但不能是constexpr常量；能够用decltype推断类型，但不能使用auto推断类型；数据成员不能指定为extern的存储类别。

C++支持在定义类的同时为类的数据成员赋初始值，举个例子：

class X{
    private:
    	int a = 2;
    	int y = {3};
    	int b[3] = {1,2,3};
    	const int ci = a;
    public:
    	...
}

注意：类的定义或声明只是在程序中增长的自定义数据类型，是没有分配相应的内存空间。只有在实例化时，才会分配相应的空间，也才会在这时初始化数据成员。

成员函数

类的成员函数也称为方法或服务。它能够在类内定义，也能够在类外定义；能够重载，也可使用默认实参。

成员函数的定义

类的成员函数有两种定义方式：

声明类时就给出成员函数的定义。

class Complex
{
    private:
    	double real,imag;
    public:
    	void init(double r,double i){
            real = r;
            imag = i;
        }
    	double getReal(){return real;}
    	double getImag(){return imag;}
};

在声明类时，只声明成员函数的原型，而后在外部定义成员函数。类外定义函数格式

返回类型 类名::成员函数名(参数列表);

其中，::是做用域运算符，用于说明这里定义的函数是指定类中的一个成员函数。

class Complex
{
    private:
    	double real,imag;
    public:
    	void init(double r,double i);
    	double getReal();
    	double getImag();
};
void Complex::init(double r,double i){
    real = r;
    imag = i;
}
void Complex::getReal(){
    return real;
}
void Complex::getImag(){
    return imag;
}

const（常量）成员函数

为了禁止成员函数修改数据成员的值，能够将它设置为const（常量）成员函数。设置的方法是在成员函数形参列表的后面加上关键字const，格式以下：
```
class X{
    T f(T1,T2,...) const;
};
```
说明：T是函数返回类型，f是函数名，T1，T2是各参加的类型。将成员函数设置为const类型后，代表该成员函数不会修改任何成员的值。

注意：只有类的成员函数才能指定为常量，通常的函数是一能的。const成员函数与const参数是不一样的。
成员函数的重载与默认实参

类的函数是能够重载，也能够指定默认实参。

在外定义的函数，只能在声明时或类外定义成员函数时才能指定默认实参，但不能在声明和定义中同时指定。

嵌套类型

嵌套类型是在类中定义的类、枚举、使用typedef声明为成员的任意类型以及使用using声明的类型别名。

嵌套类
- 定义在另外一个类的内部的类称做嵌套类，嵌套类也是一个独立的类，与外层类基本没有关系；
- 外层类的对象和嵌套类的对象是相互独立的，嵌套类对象中不包含任何外层类定义的成员，外层类也不包含嵌套类定义的成员；
- 嵌套类的访问权限由外层类决定；
- 外层类对嵌套类的成员没有特殊的访问权限，嵌套类对外层类的成员也没有访问权限；
```
class X{
    ...
        class Y{       //Y是在X类定义的嵌套类
            ...
        }
};
```
- 嵌套类也能够在类内声明，类外定义（须要外层类类型来限定）。
```
class X{
      ...
      public:
       	class Y;      //Y是X的嵌套类，定义在外层类以外
 };
 class X::Y{          //Y是在X类外定义的嵌套类
     ...
 }
```
类型别名

在类内部可使用typedef和using声明类型别名。
```
typedef T alias;
using alias = T;
```

类类型与对象

经过class定义的类型称为类类型，由类类型定义的变量称为对象。

类类型

不一样类类型的对象不能进行自动相互转换，即便两个类具备彻底相同的成员列表，它们也是不一样类型，是不能进行自动类型转换。

能够直接把类名做为类型的名字来用，从而直接指向类类型。也能够把类名跟关键字后面来使用。

Complex c;         //默认初始化Complex类型的对象
class Complex c;   //等价声明

类的声明和定义是能够分开的，能够先声明类，而暂时不定义它。

class C;   //C类的声明

对象

类是对同类事物的一种抽象，这类事物中具体的一个实例就把它看做一个对象。类和对象的关系就是数据类型和变量的关系。

对象的定义

用类定义对象的形式以下：
```
类类型名 对象名;
```
类类型是一种自定义类类型，能够定义类型的变量，也能够定义类类型的指针和引用。
```
Clock* p = &cl1;   //定义Clock类的指针p指向对象cl1
Clock& r = cl2;    //定义Clock类的引用r指向对象cl2
```
对象对成员的访问

类中成员之间能够相互访问，不受访问说明符的限制，能够直接使用成员名。类外使用只能使用“对象名.成员名”访问具备public访问说明符的成员。对象引用方法与结构类似，必须用成员运算符“.”做为对象名和对象成员之间的间隔符，格式以下：
```
对象名.数据成员名
对象名.成员函数名（实参列表）
clk1.setHour(12);
clk1.print();
```
说明：类外只能访问对象的公有成员，不能访问对象的私有和受保护成员；若是定义的对象指针，在经过指针访问对象成员时，要用成员运算符“->”做为指针对象和对象成员之间的间隔符。
对象间的赋值

不一样类类型的对象之间不能互相赋值。同类的不一样对象之间，以及同类的指针之间能够相互赋值。
```
对象名1 = 对象名2;
```
说明：进行赋值两个对象类型必须相同；进行数据成员的值复制，赋值以后，两不相干。