C++基础

C与C++的关系：

C++是从C的基础上发展而来的：

①支持新的数据类型和语法改进

②支持面向对象程序设计

③支持泛型程序设计

C++ 既支持面向对象也支持面向过程。

不要把面向对象与面向过程对立起来。

面向对象编程：类与对象

对象：现实世界中某个具体的物理实体，每个对象都包含特定的属性与行为。

类：现实世界中具有相同属性和行为的物理实体的抽象。通常既包含数据成员又包含成员函数的抽象数据类型，如结构体。

类是对对象的抽象。

对象是类的实例。

面向对象的三大特性：封装

C++中的封装-

①将数据和处理数据的函数封装为类。

②可以将某些成员声明为private从而达到信息隐藏的目的。

封装的优点：

①封装是面向对象程序设计语言实现信息隐藏的方法

②封装隐藏了具体的实现细节，使某些成员设为私有从而提高了安全性和可靠性。

简言之：封装性就是将属性（数据）和处理这些属性的行为（方法）结合起来，仅对外公开接口以达到信息隐藏的目的。

面向对象编程：继承

C++中的继承，若已有类A要创建类B而类A和类B属性和行为基本相同，则只需要在A的内容上添加新的内容即可。

继承是指子类继承父类，会自动取得父类除私有成员外的全部成员，同一类中的所有实体都会自动由该类的全部成员，做到代码重用。

继承优点：

提高了代码的重用率，节省了编程量。

面向对象编程：多态

多态性就是多种表现形式，具体来说，可以用“一个对外接口，多个内在实现方法表示”。

在面向对象理论中，多态性的定义是：同一操作作用于不同的类的对象，将产生不同的执行结果。

多态优点：

增强了程序的灵活性。

多态分为静态多态和动态多态！

面向过程是以功能为基础，采用自顶向下逐步细化的方法。

面向过程的缺陷：

①代码的可重用性和可维护性差

②数据和对数据的操作分离，数据安全不能保证。

面向对象：

将数据及其操作封装为类，以类的对象作为程序的基本元素，通过对象发送消息，从而调用相应方法完成各种功能。

面向对象程序设计的特点：

①对象为基本元素

②数据安全

③程序的维护量较小、代码的重用率高（继承）

④程序由无数个对象组成。

初始化：

C++有两种初始化方法：

复制初始化：int x = 1024;

直接初始化:int x(1024); // 创建一个名为x的数据对象，对象初始值为1024

注意：

①初始化不是简单地赋值，初始化指声明变量或对象并且赋初值；赋值指用新值覆盖变量或对象的当前值。

②直接初始化语法更灵活且效率更高

③初始化内置类型变量两种初始化几乎没有差别，对于类类型的初始化，有时只能采用直接初始化

④两种初始化的方法可以混用。

cout与输出控制字符：

C++有两种方法控制格式输出

①：用格式控制符，必须包含头文件

#include <iomanip>

②：用流对象的成员函数

名字空间：

作用防止名字冲突！

void ns1()

{

    int x;

}

 

void ns2()

{

    int x;

}

 

ns1::x != ns2::x

 

注意：名字空间的名称要符合标识符命名规则

若省略名字空间名称则名字空间只能在本文件内使用

 

在使用名字空间时 尽量使用

using std::in;

using std::cout;

using std::endl;

格式声明，用到什么声明什么

BOOL类型：

bool类型的取值只有两种true，false

输出时默认输出0或者1

用boolalpha可以改变默认的输出方式

noboolpha可以恢复默认的输出方式

#include <iostream>
using namespace std;
int main()
{
bool bval1 = 1 < 2;
bool bval2 = true;
bool bval3 = false;
bool bval4 = 4;
bool bval5 = 0;
cout << "bval1=" << bval1 << endl;
cout << "boolalpha bval1=" << boolalpha << bval1 << endl;  //boolalpha bval1= true 
cout << "noboolalpha bval1=" << noboolalpha << bval1 << endl; //noboolalpha bval1=1
cout << "bval2=" << bval2 << endl;
cout << "bval3=" << bval3 << endl;
cout << "bval4=" << bval4 << endl;
cout << "bval5=" << bval5 << endl;
system("PAUSE");
return 0;
}

有关类型的区别：string类

string对象的读写：用cin、cout读写string对象

注意：cin忽略开头所有空格、TAB、回车符号

不接收含空格的字符串！

string对象的读写：用getline读取整行文本（含空格）

#include <iostream>

#include <string>

 

using namespace std;

 

int main(void)

{

    string line;

    while (getline(cin, line)) // getline的第一个参数通常为cin，第二个参数为string对象

   {

        cout << line << endl;

   }

    // getline()以回车作为结束符（不接受换行符） 不忽略前导回车， 若第一个就是换行符，则置为空串

   system("PAUSE");

    return 0;

} 

枚举类型：

enum weekday

{sun, mon, tue, wed, thu, fri, sat};

enum weekday workday, week_end;

 

在C++ 中枚举变量可以不用enum

enum weekday

{sun, mon, tue, wed, thu, fir, sat}

 

weekday w; // 省略了enum;

 

无名枚举：不给出枚举类型名和变量，将枚举元素当符号常量用

enum

{min = 0, max = 100}

int x = min, arr[max];

 

union共用体

为最长成员的长度，可以附初值，可以做返回值和参数，类型相同的可以互相赋值。

 

常量：只读变量，只读变量必须初始化，且一旦定义不可改变

const double t = 5.2 // 必须初始化

尽量使用常量 不适用宏！

const 只读变量默认为文件局部变量，通过指定const变量为extern,就可以在整个程序中访问const对象

// file1

extern const int counter = 100;

// file2

#include <iostream>

using namespace std;

// 声明counter为外部变量

extern const int counter;

...

 

常指针：

int x = 3;

int *const p = &x; // p = &y 错误！

 

 

 

int main()

{

    int x = 5;

    int *const p = &x; //p不可变，*p可变

    *p = 60;

    cout << "++(*p)=" <<++(*p) << endl; //61

    cout << "x=" << x << endl;

    int y = 6;

     //p = &y; error

    system("PAUSE");

   

    return 0;

}

 

指向常量的指针

int x  = 3;

const int *p = &x;

// p = &y 正确

// *p = 4;

此处限制*p不能变 p可以改变！

二重常指针：

int x = 3;

int *p1 = &x;

int * const * p2 = &p1;

// p2 -= &y; 错误

// p1 = &y; 正确

引用作为形参时，对应的实参必须是变量，不能是常量或者表达式（但是常引用可以）

void display(int &x)
{
cout << x;
}
… …
display(3); //Error

 

void display(const int &x)

{

cout << x;

}

… …

display(3); //Right

常引用作为函数参数时可以作为重载的依据。