C++学习笔记1

---

目录

• 一、C++基本概念

1、对象
2、类
3、封装、继承、多态性

• 二、C++基础知识

1、命名空间
2、新的I/O流
3、作用域运算符::
4、C++中的结构体、共用体和枚举
5、const修饰符

---

• 一、C++基本概念

1、对象

面向对象的思想是把世界看做是由具有行为的各种对象组成， 任何对象都具有某些特征和行为（数据和算法），
即特征就是数据， 行为就是算法， 算法就是对象的函数。

对象就是一个变量，包含数据和方法
2、类

具有共性的实体的抽象，其本质是自定义数据类型；类的设计是关键一步，直接影响到代码重用和程序扩充

寻求一个大系统中事物的共性， 将具有共性的系统确定为一个类；设计类要有一个明确的目标， 一个好的类应该是容易理解和使用的

3、封装、继承、多态性

封装：把数据保护起来， 用类的方法对数据进行操作

继承：防止重复开发；我们设计好一个类， 再设计另外一个类的时候， 第 2 类和第 1 个类有共性， 第 2 个类可以继承第 1 个类的属性及方法。类间具有共享特征（包括数据和程序代码的共享）、类间具有新增部分（包括非共享的数据和程序代码）、类间具有层次结构

多态：多态就是有多种状态。 一个函数可以完成多个功能就叫多态。

           在 c 语言中： 函数名是不能重名的int abs(int)  

           在 C++中： 函数名是可以重名的  int abs(int)    float abs(float)   通过传递不同的参数决定调用哪个 abs 函数。

在 C++中确定一个函数的入口地址， 不仅仅是通过函数名的。 C++中确定一个函数的入口地址是通过函数名和参数
来共同确定的， 这两者共同决定一个函数的入口地址。

---

• 二、C++基础知识

1、命名空间

所谓命名空间， 是指标识符（变量或函数等） 的各种可见范围。在编程中如果在一个函数中定义两个名字相同的变量， 便会报重定义错误。 命名空间就是为解决这一类问题解决的

#include<iostream>
//i:input
//o:output
int main()
{
    std::cout<<"hello C++"<<std::endl; //std命名空间中的cout
    //std::endl 代表换行
    // <<代表流向
    return 0;
}

命名空间的定义：

namespace myName{
                                  //namespace member
                                   } 注意此处没有分号
namespace CompanyA{
                                      void fun()
                                                   { }

                                      int num;
                                      }

CompanyA::fun(); CompanyA::num=100;
 

#include<iostream>
//A 命名空间
namespace A{
    int num;
    void fun(void)//C++中如果没有参数， 要填写 void， 不能空着
    {
        std::cout<<"A 中的 fun"<<std::endl;
    }
} 
//B 命名空间
namespace B{
    int num;
    void fun(void)//C++中如果没有参数， 要填写 void， 不能空着
    {
        std::cout<<"B 中的 fun"<<std::endl;
    }
}
/*-----------------------使用方式1-----------------------------*/
int main()
{
    //fun();//错误， 不知道调用 A 命名空间的 fun 还是 B 命名空间的 fun
    A::fun();//调用 A 命名空间的 fun
    B::fun();//调用 B 命名空间的 fun
    A::num=10;
    B::num=20;
    std::cout<<"A 中的 num= "<<A::num<<std::endl;
    std::cout<<"B 中的 num= "<<B::num<<std::endl;
    return 0;
}
/*-----------------------使用方式2-----------------------------*/
using namespace B;
//using namespace A;
int main()
{
    //B::fun();
    fun();//如果使用 A 和 B 两个命名空间 fun 调用存在二意性
    return 0;
}

使用方式一：引用不同空间的变量和函数的时候需要带上命名空间和作用域运算符

使用方式二：使用之前用using声明所使用的命名空间，则可以直接引用所声明命名空间的变量和函数；若果同时使用using声明了两个命名空间，两个空间都有的变量和函数按方式一使用，某个命名空间独有的变量或函数也可直接使用

2、新的I/O流

I/O 流： 从某种 I/O 设备上输入或输出的字符序列

cout和cin是对象变量

cin 可以连续输入多个数据； cout 可以连续输出多个数据

默认情况下使用了系统缺省的格式， 但可以进行格式控制

endl 操作符号相当于C语言中的换行符

#include<iostream>
int main()
{
    //printf("name is %s\n","lucy");
    std::cout<<"name is"<<"lucy"<<std::endl;
    int num=0;
    //scanf("%d",&num);
    //std::cin 代表标准输入， 就是键盘
    std::cin>>num;
    std::cout<<"num= " <<num <<std::endl;
    char name[32]=" ";
    std::cin>>name;
    std::cout<<"name is "<<name<<std::endl;
    //scanf("%d %s",&num,name);
    std::cin>>num>>name;//200tom 也是可以的
    //不同变量的输入中间用空格隔开，整形和字符型时也可以不隔开直接连着输入
    std::cout<<"num= " <<num <<std::endl;
    std::cout<<"name is "<<name<<std::endl;
    return 0;
}

一个字符串中含有空格的话上述方式无法获取完整输入，需使用如下方式：

int main()
{
    char name[32]=" ";
    //std::cin>>name;//lucy tom 输入的话， 只获取 lucy， 遇到空格结束
    std::cin.getline(name,sizeof(name),'\n');
    //第三个参数可以不写。 第三个参数写了的话， 以第 3 个参数结束获取输入
    //getline 的方法， 字符串中间可以有空格
    //读取到name-1个字符或者遇到换行符就停止读取
    std::cout<<"name is "<<name<<std::endl;
    return 0;
}

在主函数前加上 using namespace std;  就可以省略上面的诸多std::

cout可以控制输出格式

int main()
{
    int num=100;
    cout<<"num= "<<dec<<num<<endl;//用十进制输出 num
    cout<<"num= "<<hex<<num<<endl;//用十六进制输出 num
    cout<<"num= "<<oct<<num<<endl;//用八进制输出 num
    return 0;
}

3、作用域运算符::

变量在程序中的起作用范围成为作用域；简单分为全局作用域、局部作用域和语句作用域；范围越小优先级越高，遵循就近原则；

如果希望在局部变量的作用域内使用同名的全局变量， 可以在该变量前加上”::”,”::” 称为作用域运算符

#include<iostream>
using namespace std;
int avar=10;
int main()
{
    int avar=20;
    cout<<"avar is : "<<avar<<endl;//用的是局部作用域
    avar=25;
    cout<<"avar is : "<<avar<<endl;
    cout<<"avar is : "<< ::avar <<endl;//用的是全局作用域
    ::avar = 30;
    cout<<"avar is : "<< ::avar <<endl;
    return 0;
}

4、C++中的结构体、共用体和枚举

定义方法和C语言一致，没有任何区别

但是在定义该类型变量时可以C++直接使用结构体、共用体或者枚举的类型名定义变量，而不用加上对应关键字

enum BOOL{FALSE,TRUE};

struct STRING{

                         char *prt;

                         int length;

                        };

在 c 语言中
                          enum BOOL done;
                          struct STRING str;

在 C++中
                          BOOL done;
                          STRING str;

C++中加上也行，并不会保存，但是习惯不加

5、const修饰符

const修饰符是只读的意思

用const修饰的普通变量不能再次赋值

const int *p=&data1;//不能通过 p 去改变 p 指向的变量的内容

                               //const 修饰的是 p， p 可以更改自身的指向， 但不能通过*p 去改变 p 指向的空间赋值

int * const p=&data1;//const 修饰 p， 代表 p 是个只读指针
                                         //不能改变 p 本身的指向， 但可以通过*p 改变 p 指向的空间的内容

const int * const p=&data1;//不能改变 p 本身的指向,也不能通过*p 改变 p 指向的空间的内容

以上三点在C语言和C++中是一样的

C语言中const修饰的变量可以通过一个指向该变量的指针进行修改，容易出现内存风险

但是在C++中不一样 如下：

#include<iostream>
using namespace std
int main()
{
    const int num=100;
    //int *p=&num;//类型不匹配,不强转， 在 C++里会报错
    int *p=(int *)&num;
    *p=300;
    cout<<"num= "<<num<<endl;
    //100,是符号常量表里的 num 的值， 而不是变量存储空间里的值， 变量存储空间里的值确实改为 300 
    cout<<"*p= "<<*p<<endl;//300
    cout<<&num<<endl;
    cout<<p<<endl;
    return 0;
}