C++笔记

C++简介

1.开发者：Bjarne Stroustrup于1979年在贝尔实验室开发的。
2.与c的区别：
C++是面向对象的，C是面向过程的；
C++函数库紧密，C的函数库松散

C++面向过程：

基本概念

类：描述对象行为/状态的模板，抽象
对象：具有行为和状态，具体
方法：表示一种行为
标识符：用来表示变量、函数、类、模块或者其他用户定义项目的名称。
以字母或者下划线开头，组成：字母、数字、下划线
C++关键字：C++专用词汇
函数：一组一起执行一个任务的语句
HelloWorld代码

#include <iostream>//<iostream>为C++的头文件
using namespace std;
 //告诉编译器使用标准（std）命名空间
int main()// main() 是程序开始执行的地方
{
   cout << "Hello World"; // 输出 Hello World
   return 0;//结束main()函数
}

注释：解释代码的含义
单行注释：//…
多行：/* … */

基本类型和变量

1.常用的数据类型：
bool 布尔型 true或者false
char 字符型 一个字符
int 整型 整数
float 浮点型 单精度的浮点值
double 双浮点型 双精度的浮点值
2.变量：程序可操作的存储区的名称，变化的量。
定义：

int number = 20；//int：表示数据类型为整型，number 为变量名，‘=20’为给number变量赋值20

3.作用域：即变量的有效范围
局部变量：在函数或者代码块内部声明
形参：函数参数中定义声明的
全局：所有函数外部声明的
4.引用：可以理解为别名

int i = 17；
int &r = i;//r为i的引用，即i的别名，引用必须要被初始化

5.指针：是一个变量，其中的值是另一个变量的指针。

int  var = 20;   // 实际变量的声明    
int  *ip;        // 指针变量的声明      
ip = &var;       // 在指针变量中存储 var 的地址
cout << *ip << endl; 访问指针中地址的值

&为取地址符，*为解地址符
6.指针与引用
6.1 不存在空引用。引用必须连接到一块合法的内存。
6.2 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
6.3 引用必须在创建时被初始化。指针可以在任何时间被初始化。
6.4引用本身不是一个对象，不能定义指向引用的指针，指针是对象可以定义指针的引用

int i = 42；
int *p;
int *&r = p;//r是一个对指针p的引用

常量

1.常量：值固定不变的量
2.常量可以是任何的数据类型
3.定义：大写字符定义
#define预处理 例：#define NUMBER 10
const关键字 例：const int NUMBER = 10

表达式

1.算数运算符：+ ,- ,* ,/ ,%(取模）,++（自增）, --（自减）
2.关系运算符：==相等, ！=不等, > ,< ,>= ,<=.
3.逻辑运算符：&& 与，|| 或，！非
4.位运算法
& 如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。
| 如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。
^ 如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果。
~ 二进制补码运算符是一元运算符，具有"翻转"位效果，即0变成1，1变成0。
<< 二进制左移运算符。左操作数的值向左移动右操作数指定的位数。
‘>>’ 二进制右移运算符。左操作数的值向右移动右操作数指定的位数。

函数

1.定义

int number(int a);//函数声明，告诉编译器如何调用，函数体可以自己单独定义
int number(int a )//int 为函数返回值类型，函数名为number，int为参数类型，a 为形式参数
{
//函数体
}

2.参数传递
a.传值参数：
该方法把参数的实际值赋值给函数的形式参数。在这种情况下，修改函数内的形式参数对实际参数没有影响。

int i = 0;//int 类型的初始变量
int i = n;//i是n的值的副本
i = 42;//i的值改变，n 的值不变
void swap(int x,int y);//声明一个交换两个数的函数，x,y为形参
swap(a,b);//a,b的值不变

b.指针
该方法把参数的地址赋值给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。

void swap(int *x,int *y);声明一个交换两个数的函数，*x,*y为形参
swap(&a,&b);//a,b的值发生变化

c.引用
该方法把参数的引用赋值给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。

void swap(int &x, int &y);
swap(a,b);//a,b的值发生变化

数组和字符串

数组–
1.定义：存储一系列固定大小，相同类型的顺序集合
2.声明：

type arrary [arrarysize];//type为数组类型，arrary为数组名，arrarySize是数组的容量

3.初始化：

int number[5]={10,20,30,40,50};
int number[]={10,20,30,40,50};

4.访问：

int number[5]={10,20,30,40,50};//通过数组下标访问数组内的某个元素
for(int i = 0; i < 5;I++)
{
cout<<number[i]<<endl;//通过for循环遍历输出数组所有元素。
}

多维数组以此类推；
字符串-
1.定义：采用String 来定义字符串

string str1 = "runoob";   
string str2 = "google";

2.常用的操作
append() – 在字符串的末尾添加字符
find() – 在字符串中查找字符串
insert() – 插入字符
length() – 返回字符串的长度
replace() – 替换字符串
substr() – 返回某个子字符串
strcpy(s1, s2); 复制字符串 s2 到字符串 s1。
vector-
1.定义:对象的集合，也叫做容器
2.声明：
必须包含头文件：#include using std :: vector;
vector v1 ;T为容器的类型，可以是int double等等
3.操作：
.empty() 判空
size() 返回元素个数

数据结构

1.定义：

struct type_name {//type_name为结构体类型名称
member_type1 member_name1;//member_type1 member_name1 是标准的变量定义
member_type2 member_name2;
member_type3 member_name3;
} object_names;//变量名

typedef关键字
可以为创建的类型取一个"别名"

typedef struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
}Books;//可以直接使用Books来定义Books类型的变量

2.访问

struct Books// 声明一个结构体类型 Books 
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};
 Books Book1; // 定义结构体类型 Books 的变量 Book1
 strcpy( Book1.title, "C++ 教程");
   cout << "第一本书标题 : " << Book1.title <<endl;// 输出 Book1 信息

语句

1.简单语句：以分号结尾
2.条件语句：
a.if

if(boolean_expression){   
 // 如果布尔表达式为真将执行的语句
 }//布尔表达式为假，则执行下边的语句

b.if -else

if(boolean_expression)
{
   // 如果布尔表达式为真将执行的语句
}
else
{
   // 如果布尔表达式为假将执行的语句
}

c.嵌套
可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。
d.switch
测试一个变量等于多个值，加break可以跳出，不加，则会从头一直判断到结束

switch(expression){
    case constant-expression  :
       statement(s);
       break; // 可选的
    case constant-expression  :
       statement(s);
       break; // 可选的
    // 您可以有任意数量的 case 语句
    default : // 可选的
       statement(s);
}

switch 也可以嵌套使用
3.循环语句
a.while

while(condition)//
{
   statement(s);
}//先判断条件，当条件为真时候执行语句；，为假时结束循环

b.do - while

do
{
   statement(s);

}while( condition );//先循环，在判断条件，条件为真时执行语句，为假时结束循环

c.for

for( int a = 10; a < 20; a = a + 1 )
   {
       cout << "a 的值：" << a << endl;
   }
   //执行a = 10,然后进行判断，如果a < 20为真，则执行主体语句，然后会跳到 a = a + 1;，再进行判断操作，如果a < 20为假则结束循环。

C++面向对象：

类和对象

类

1.定义：描述对象行为/状态的蓝图

class Box //class为类关键字，Box为类的名称
{
   public://类成员的访问修饰符
      double length;   // 盒子的长度
      double breadth;  // 盒子的宽度
      double height;   // 盒子的高度
      //Box类包含三个数据成员
      double get(void);//类成员函数声明
};
double Box::get(void)//成员函数定义
{
    return length * breadth * height;
}

a.类成员函数
指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。类成员函数是类的一个成员，它可以操作类的任意对象，可以访问对象中的所有成员。
b.类访问修饰符
它防止函数直接访问类类型的内部成员
public: // 公有成员
公有成员在程序中类的外部是可访问的。您可以不使用任何成员函数来设置和获取公有变量的值
protected：// 受保护成员
受保护成员变量或函数与私有成员十分相似，但有一点不同，protected（受保护）成员在派生类（即子类）中是可访问的。
private: // 私有成员
私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员。
c.构造和析构函数
两者都是特殊的成员函数
构造：每次创建类的新对象时候执行
析构：每次删除类的对象的时候执行

class Box 
{	
   private:
      double length;   // 盒子的长度
      double breadth;  // 盒子的宽度
      double height;   // 盒子的高度
      //Box类包含三个数据成员
   public:
   	  Box();//不带参的构造函数声明，必须与类名一致
   	  Box(double length;double breadth;double height);
   	  //带参数的构造函数声明
   	  ~Box();//析构函数声明
      double get(void);//类成员函数定义  
};

d.友元函数
类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。

class Box 
{
   private:
      double length;   // 盒子的长度
      double breadth;  // 盒子的宽度
      double height;   // 盒子的高度    
   public:
   	  friend void printWidth(Box box);
   	  //友元函数声明
};

e.this指针
每一个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数。因此，在成员函数内部，它可以用来指向调用对象。
f.静态成员

class Box 
{
   public:
      static double length;   //静态成员声明 
};

当我们声明类的成员为静态时，这意味着无论创建多少个类的对象，静态成员都只有一个副本。
静态成员函数只能访问静态成员数据、其他静态成员函数和类外部的其他函数。

对象

定义：对象具有的状态和行为。

Box Box1;//声明Box1，类型为 Box

访问：类的对象的公共数据成员可以使用直接成员访问运算符 .来访问。私有的可以调用公共成员函数来访问。

 Box Box1; 
	 Box1.height = 5.0; 
     Box1.length = 6.0; 
     Box1.breadth = 7.0;

继承

1.定义：依据另一个类来定义一个类
基类：指定的类
派生类：新建的类
一个基类可以有多个派生类

class Animal {// 基类
     eat() 函数
     sleep() 函数
};
class Dog : public Animal {//派生类，为公有继承类型
     bark() 函数
};

2.继承类型
公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。

多态

1.定义：多种形态，同一函数声明的不同实现方式
2.虚函数：在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。
3.纯虚函数：
基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。

class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      virtual int area() = 0;//纯虚函数
};

接口（抽象类）

1.数据抽象
只向外界提供关键信息，并隐藏其后台的实现细节，即只表现必要的信息而不呈现细节。

class Adder{
   public:
      Adder(int i = 0)//构造函数
      {
        total = i;
      }
      void addNum(int number)//接口
      {
          total += number;
      }
   private:
      // 对外隐藏的数据
      int total;
};

2.接口：描述了类的行为和功能，而不需要完成类的特定实现

class Box
{
   public:
      virtual double getVolume() = 0;  // 纯虚函数
   private:
      double length;      // 长度
      double breadth;     // 宽度
      double height;      // 高度
};

重载运算符和重载函数

1.运算符重载： 重新定义运算符，operator关键字
不可重载的运算符
.：成员访问运算符
., ->：成员指针访问运算符
::：域运算符
sizeof：长度运算符
?:：条件运算符
#： 预处理符号

      Box operator+(const Box& b)// 重载 + 运算符，用于把两个 Box 对象相加，
      {
         Box box;
         box.length = this->length + b.length;
         box.breadth = this->breadth + b.breadth;
         box.height = this->height + b.height;
         return box;
      }

2.函数重载：
同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同

class printData
{
   public:
      void print(int i) {
        cout << "整数为: " << i << endl;
      }
      void print(double  f) {
        cout << "浮点数为: " << f << endl;
      } 
      void print(char c[]) {
        cout << "字符串为: " << c << endl;
      }
};//print（）函数重载