您的位置:首页 > 编程语言 > C语言/C++

开发成长之路(6)-- C++从入门到开发(C++入门不难)

2021-05-12 16:30 961 查看

文章目录

  • C++ 动态内存
  • 这个图有点偏差啊,C++是要排在QT之前的,回头我会对这个图进行一波的微调。

    这已经是进入了第二个阶段了,此前如果C语言基础还没有打好的小伙伴可以再补一下C语言:
    开发成长之路(1)-- C语言从入门到开发(入门篇一)
    开发成长之路(2)-- C语言从入门到开发(函数与定制输入输出控制函数)
    开发成长之路(3)-- C语言从入门到开发(讲明白指针和引用,链表很难吗?)
    开发成长之路(4)-- C语言从入门到开发(距离开发,还差这一篇)
    开发成长之路(5)-- C语言从入门到开发(仿ATM机项目,我写的第一个项目)

    C++背景介绍:C++入门真的不难

    C++和C经常被放在一起写,这难道还需要我再解释什么吗?
    C/C++。

    C++,在C语言的基础上增添了新的特性,主要为类。
    其实类也是源自于对C语言结构体的发扬光大。正因为有了类的出现,C++带有着强的封装性、继承性、多态性。
    而后其它的一切,都是由于这些特性而做的二次开发,从而在发展的道路上一骑绝尘。

    大家觉得C++难,也就是难在这些后继发展的内容上吧。
    这个阶段,让我们忘掉那些,探求最简单的C++基本语法!!!

    C++语言与C语言的异同

    技术点 异/同
    环境搭建
    编码规范 略异
    基本数据类型
    标准输入输出
    运算符
    字符串 略异
    分支循环
    函数
    类/结构体
    指针/引用
    分文件编程
    调试

    1、编码规范
    在C++中引用的头文件和C中的头文件不太一样,但是这并不妨碍二者互用,兼容的。
    C里面的输入输出头为:

    include<iostream>
    
    using namespace std;	//这一行意为使用名空间std,std里面包含了很多东西

    2、标准输入与输出
    在C++里面,输入输出没那么的麻烦,

    cin>>输入内容>>代码>>继续输入;
    cout<<输出内容<<代码<<继续输出;

    3、字符串。
    C++中有专门的字符串类。

    #include <string>
    using namespace std;

    支持的方法有:

    函数 目的
    strcpy(s1, s2); 复制字符串 s2 到字符串 s1。
    strcat(s1, s2); 连接字符串 s2 到字符串 s1 的末尾。连接字符串也可以用 + 号
    strlen(s1); 返回字符串 s1 的长度。
    strcmp(s1, s2); 如果 s1 和 s2 是相同的,则返回 0;如果 s1<s2 则返回值小于 0;如果 s1>s2 则返回值大于 0。
    strchr(s1, ch); 返回一个指针,指向字符串 s1 中字符 ch 的第一次出现的位置。
    strstr(s1, s2); 返回一个指针,指向字符串 s1 中字符串 s2 的第一次出现的位置。

    4、类,后面细讲

    整张图来看的明白(源自菜鸟编程):

    其他的不必讲了吧,讲一下那个变量和方法、访问修饰符。

    类方法

    变量,称为类的属性。函数,称为类的方法。

    我们来一个实际的例子看一下:

    class Box
    {
    public:
    double length;      // 长度
    double breadth;     // 宽度
    double height;      // 高度
    
    double getVolume(void)
    {
    return length * breadth * height;
    }
    };

    也可以在类的外部使用范围解析运算符 :: 定义该函数

    double Box::getVolume(void)
    {
    return length * breadth * height;
    }

    值得注意的是,在分文件写代码的时候,需要将类及类方法声明在.h文件中,而类方法的实现放在.cpp文件中,这时候就需要下面的写法了。

    初始化类对象,并调用成员函数的方法:

    Box myBox;          // 创建一个对象
    
    myBox.getVolume();  // 调用该对象的成员函数

    或:

    Box *myBox = new Box();          // 创建一个对象
    
    myBox0->getVolume();  // 调用该对象的成员函数

    C++ 类访问修饰符

    类成员的访问限制是通过在类主体内部对各个区域标记 public、private、protected 来指定的。

    为什么说C++有很强的封装性呢,就是因为这三个类访问修饰符。
    且看下去:

    class Base {
    public:
    // 公有成员,可以在类外被随意访问
    
    protected:
    // 受保护成员,受保护继承的子类可以使用,自己和友元也可以使用
    
    private:
    // 私有成员,只能在本类内使用,友元函数也行
    
    };

    我们一般将某些必须开放的接口设置为公有,有些看情况设置为保护,其余一律设为私有。
    类的属性不建议公有!!!

    示例:

    class Box
    {
    public:
    void setWidth( double wid );
    double getWidth( void );
    
    private:
    double length;
    double width;
    };
    
    // 成员函数定义
    double Box::getWidth(void)
    {
    return width ;
    }
    
    void Box::setWidth( double wid )
    {
    width = wid;
    }

    类继承

    有public, protected, private三种继承方式,它们相应地改变了基类成员的访问属性。

    继承方法 基类 public 成员,protected 成员,private 成员的访问属性在派生类中分别变成:
    public 继承 public, protected, private
    protected 继承 protected, protected, private
    private 继承 private, private, private

    可以看出,private 成员只能被本类成员(类内)和友元访问,不能被派生类访问;protected 成员可以被派生类访问。

    示例:

    class A{
    public:
    int a;
    A(){
    a1 = 1;
    a2 = 2;
    a3 = 3;
    }
    void fun(){
    cout << a1 << endl;   //正确
    cout << a2 << endl;   //正确
    cout << a3 << endl;   //正确
    }
    public:
    int a1;
    protected:
    int a2;
    private:
    int a3;
    };
    
    class B : public A{
    public:
    int a;
    B(int i){
    A();
    a = i;
    }
    void fun(){
    cout << a << endl;       //正确,public成员
    cout << a1 << endl;       //正确,基类的public成员,在派生类中仍是public成员。
    cout << a2 << endl;       //正确,基类的protected成员,在派生类中仍是protected可以被派生类访问。
    cout << a3 << endl;       //错误,基类的private成员不能被派生类访问。
    }
    };

    构造/析构函数

    在初始化类的对象的时候会需要用到类的构造函数,构造函数的名称与类的名称是完全相同的,并且不会返回任何类型、

    构造函数可用于为某些成员变量设置初始值。

    来看个例子:

    class Line
    {
    public:
    Line();  // 这是构造函数
    };
    
    // 成员函数定义,包括构造函数
    Line::Line(void)
    {
    cout << "Object is being created" << endl;
    }

    默认的构造函数没有任何参数,但如果需要,构造函数也可以带有参数。

    像这样:

    class Line
    {
    public:
    Line(double len);  // 这是构造函数
    
    private:
    double length;
    };
    
    // 成员函数定义,包括构造函数
    Line::Line( double len)
    {
    cout << "Object is being created, length = " << len << endl;
    length = len;
    }

    还可以这样:

    Line::Line( double len): length(len)
    {
    cout << "Object is being created, length = " << len << endl;
    }

    看个人喜好了。

    析构函数呢,相对比较简单,但是也是有坑在里面的。

    类的析构函数是类的一种特殊的成员函数,它会在每次删除所创建的对象时执行。
    一般用于程序员手动回收内存。

    class Line
    {
    public:
    Line();   // 这是构造函数声明
    ~Line();  // 这是析构函数声明
    };
    
    // 成员函数定义,包括构造函数
    Line::Line(void)
    {
    cout << "Object is being created" << endl;
    }
    Line::~Line(void)
    {
    cout << "Object is being deleted" << endl;
    }

    拷贝构造函数

    拷贝构造函数是一种特殊的构造函数,它在创建对象时,是使用同一类中之前创建的对象来初始化新创建的对象。

    class Line
    {
    public:
    Line( int len );             // 简单的构造函数
    Line( const Line &obj);      // 拷贝构造函数
    ~Line();                     // 析构函数
    
    private:
    int *ptr;
    };
    
    // 成员函数定义,包括构造函数
    Line::Line(int len)
    {
    cout << "调用构造函数" << endl;
    // 为指针分配内存
    ptr = new int;
    *ptr = len;
    }
    
    Line::Line(const Line &obj)
    {
    cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;
    ptr = new int;
    *ptr = *obj.ptr; // 拷贝值
    }

    this指针

    this指针存在于类中,指代的是这个类本身的意思。
    其实我也想不出来太多它必须存在的场景,碧如说:参数名和类属性名一样的时候,或者函数指针参数名和类方法名一样的时候吧。

    反正看到this的时候不要大惊小怪就好啦。

    关于类,大致讲到这里。

    C++ 动态内存

    了解一下堆栈:

    栈:在函数内部声明的所有变量都将占用栈内存。
    堆:这是程序中未使用的内存,在程序运行时可用于动态分配内存。

    使用 new 运算符来为任意的数据类型动态分配内存的通用语法:

    new data-type;

    使用 delete 操作符释放它所占用的内存:

    delete pvalue;        // 释放 pvalue 所指向的内存

    示例:

    double* pvalue  = NULL; // 初始化为 null 的指针
    pvalue  = new double;   // 为变量请求内存
    
    balabala
    
    delete pvalue;        // 释放 pvalue 所指向的内存

    数组的动态内存分配

    直接上手吧:

    char* pvalue  = NULL;   // 初始化为 null 的指针
    pvalue  = new char[20]; // 为变量请求内存
    
    delete [] pvalue;        // 删除 pvalue 所指向的数组

    对象的动态内存分配

    int main( )
    {
    Box* myBoxArray = new Box();
    
    delete myBoxArray;
    return 0;
    }

    先到这里啦,我还有点事情。

  • 内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
    标签: