C++初探：qt应用

本文主要是介绍C++初探：qt应用，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

C++

面向对象

后缀 .cpp
编译： g++ xxx.cpp

**封装：**封装的抽象过程，描述一类事物的特点
**类：**一类事物的统称
**对象：**某类事物的一个特别/个体

如何描述一类事物：数据成员，成员方法。

实例化对象：int i;
例： A a1； “实例化一个A类型的对象a1”

继承：核心，在原有的特点/功能上加上新特点/功能。
多态：延申，同一条命令作用在不同对象上显示效果不同。

一、输入和输出

1.cin （输入） – 默认与键盘链接，接受从键盘输入的数据信息。
语法：cin >> 变量；
2.cout（输出） – 默认与屏幕链接，将数据显示到屏幕上。
语法： cout << 变量；

如果没指定名空间：using namespace std；
域解析运算符

#include <iostream>
using namespace std;

int main()
{
    int i;
    char str[32];

    cout << "Hello World!" << endl;
    cin >> i;
    cout << "i = " << i << "    &i = " << &i << endl;  //C++能自动识别变量类型
    cin >> str;
    cout << "str = " << str << endl;

    return 0;
}

注意：C++在创建变量时，必须给变量一个初始值，否则会报错

二、封装

1.1 封装定义-属性和行为

封装的意义：

将属性和行为作为一个整体，表现生活中的事物
将属性和行为加以权限控制

语法： class 类名{ 访问权限：属性 / 行为 };

class Clock
{
public:
    void ShowTime(); 
    void SetTime(int h,int m,int s);
private:
    int hour;
    int minute;
    int second;
};

1.2 访问权限

访问权限有三种：
公共权限  public        ==类内可以访问  类外可以访问==
保护权限  protected     ==类内可以访问  类外不可以访问==
私有权限  private       ==类内可以访问  类外不可以访问==

示例：

#include <iostream>
me/xiaolei/teacher/example/c++/hello.cpp' '
using namespace std;

//内联函数inline  1类内实现  2用inline关键字类内声明，实现可以写在类外
//public protected private

class Clock
{
public:
    void ShowTime(); 
    void SetTime(int h,int m,int s);
private:
    int hour;
    int minute;
    int second;
};

void Clock::ShowTime()
{   cout << hour << ":" << minute << ":" << second << endl;  }

void Clock::SetTime(int h,int m,int s)  
{   hour = h; minute = m; second = s;   }

int main()
{   
    Clock c1;
    
    c1.ShowTime();
    
    return 0;
}

inline 内联函数带参宏，建议性机制
宏占用的是编译时间，不占用运行时间

对一个类进行计算大小，只能计算数据类型的大小，函数不计入空间大小

三、类中的特殊函数

3.1 构造函数

对象的初始化和清理也是两个非常重要的安全问题
一个对象或者变量没有初始状态，对其使用后果是未知
同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

构造函数作用：初始化，在一个对象生成的时候被隐式调用

默认有一个系统生成的构造函数，若果我们自行实现了构造函数，系统默认的那个不再生成
长相：函数与类同名，不需要返回值，可传参(1或多)，可无参

构造函数语法：类名(){}

构造函数，没有返回值也不写void
函数名称与类名相同
构造函数可以有参数，因此可以发生重载
程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次

代码演示：

#include <iostream>
using namespace std;
/*类中的特殊函数*/
/*
构造函数：作用：初始化，在一个对象生成的时候被隐式调用
默认有一个系统生成的构造函数，若我们自行实现了构造函数，系统默认的那个不再生成
长相：函数名与类同名，不需要返回值，可传参（可1个或多个）可无参
构造函数可以同时存在多个
*/

class Clock
{
public:
    Clock();      //构造函数可以存在多个
    Clock(int h);
    void ShowTime();
    void SetTime(int h,int m,int s);
private:
    int hour;
    int minute;
    int second;
};
Clock::Clock()
{
    cout << "Clock()" << endl;
    hour = minute = second = 0;
}
Clock::Clock(int h)
{
    cout << "Clock(int)" << endl;
    hour = h ;      minute = second = 0;
}
void Clock::ShowTime()
{   cout << hour << ":" << minute << ":" << second << endl;  }
void Clock::SetTime(int h,int m,int s)
{   hour = h; minute = m; second = s;   }

int main()
{
    Clock c0;
    Clock c1(4);
    Clock c2(14,15);
//  c1.ShowTime();

    return 0;
}

类外不能复制

#include <iostream>
using namespace std;
/*类中的特殊函数*/
/*
构造函数：作用：初始化，在一个对象生成的时候被隐式调用
默认有一个系统生成的构造函数，若我们自行实现了构造函数，系统默认的那个不再生成
长相：函数名与类同名，不需要返回值，可传参（可1个或多个）可无参
构造函数可以同时存在多个
*/

class Clock
{
public:
    Clock(int h=0,int m=0,int s=0);
    void ShowTime();
    void SetTime(int h,int m,int s);
private:
    int hour;
    int minute;
    int second;
};
Clock::Clock(int h,int m,int s)
{
    cout << "Clock(3*int)" << endl;
    hour = h ;
    minute = m;
    second = s;
}
void Clock::ShowTime()
{   cout << hour << ":" << minute << ":" << second << endl;  }
void Clock::SetTime(int h,int m,int s)
{   hour = h; minute = m; second = s;   }

int main()
{
    Clock c0;
    Clock c1(4);
    Clock c2(14,15);
//  c1.ShowTime();

    return 0;
}

3.2 析构函数

析构函数作用：清理或销毁，在一个对象生命周期即将终止时被隐式调用

默认有一个系统生成的析构函数，若果我们自行实现了构造函数，系统默认的那个不再生成
长相：函数与类同名，前面加~，不需要返回值

析构函数语法： ~类名(){}

析构函数，没有返回值也不写void
函数名称与类名相同,在名称前加上符号 ~
析构函数不可以有参数，因此不可以发生重载
程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

给变量加个大括号相当于一个临时变量

代码演示：

#include <iostream>
using namespace std;
/*类中的特殊函数*/
/*
析构函数：作用：清理或销毁，在一个对象生命周期即将终止时被隐式调用
默认有一个系统生成的析构函数，若我们自行实现析构函数，系统默认的那个不再生成
长相：函数名与类同名，前面加～，不需要返回值，不可传参
*/

class Clock
{
public:
    Clock(int h=0,int m=0,int s=0);
    ~Clock();
    void ShowTime();
    void SetTime(int h,int m,int s);
private:
    int hour;
    int minute;
    int second;
};
Clock::Clock(int h,int m,int s)
{
    cout << "Clock(3*int)" << endl;
    hour = h ;
    minute = m;
    second = s;
}
Clock::~Clock()
{
    cout << "~Clock()  " << hour <<  endl;
}

void Clock::ShowTime()
{   cout << hour << ":" << minute << ":" << second << endl;  }
void Clock::SetTime(int h,int m,int s)
{   hour = h; minute = m; second = s;   }

int main()
{
    Clock c0;
    {
    Clock c2(14,15);
    }
    Clock c1(4);

    return 0;
}

3.3 拷贝构造函数

拷贝构造函数作用：初始化，在一个对象生成的时候，且用相同类型的已存在的对象初始化时调用拷贝构造

默认有一个系统生成的拷贝构造函数，若果我们自行实现了拷贝构造函数，系统默认的那个不再生成
长相：函数与类同名，不需要返回值，可传参(参数为常量的引用)。

代码演示：常量的引用

”同一块存储的空间有相同的名字“

#include <iostream>
using namespace std;
/*类中的特殊函数*/
/*
拷贝构造函数：作用：初始化 ，在一个对象生成时，且用相同类型的已存在的对象初始化时调用拷贝构造 
默认有一个系统生成的拷贝构造函数，若我们自行实现了拷贝构造函数，系统默认的那个不再生成
长相：函数名与类同名，无返回值，参数为常引用
*/

class Clock
{
public:
    Clock(int h=0,int m=0,int s=0);
    Clock(const Clock &other);
    ~Clock();
    void ShowTime();
    void SetTime(int h,int m,int s);
private:
    int hour;
    int minute;
    int second;
};
Clock::Clock(int h,int m,int s)
{
    cout << "Clock(3*int)" << endl;
    hour = h ;
    minute = m;
    second = s;
}
Clock::Clock(const Clock &other)
{
    cout << "Clock(&)" << endl;
    hour = other.hour;
    minute = other.minute;
    second = other.second;
}
Clock::~Clock()
{
    cout << "~Clock()  " << hour <<  endl;
}

void Clock::ShowTime()
{   cout << hour << ":" << minute << ":" << second << endl;  }
void Clock::SetTime(int h,int m,int s)
{   hour = h; minute = m; second = s;   }

int main()
{
    Clock c1(4);
    Clock c2 = c1;
    c2.ShowTime();

    return 0;
}

四、C++内存模型

C++程序在执行时，将内存大方向划分为4个区域

代码区：存放函数体的二进制代码，由操作系统进行管理的
全局区：存放全局变量和静态变量以及常量
栈区：由编译器自动分配释放, 存放函数的参数值,局部变量等
堆区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收

new && delete

C++中利用new操作符在堆区开辟数据

堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符 delete

语法：new 数据类型

利用new创建的数据，会返回该数据对应的类型的指针

示例1：基本语法

#include <iostream>
using namespace std;

int main()
{
    char *p = new char;
    if(p == NULL)
        return -1;

    *p = 'a';
    cout << *p << endl;

    delete p;  //利用delete释放堆区数据

    return 0;
}

示例2：开辟数组

#include <iostream>
using namespace std;

/*  new delete */

class Clock
{
public:
    Clock(int h=0,int m=0,int s=0);
    Clock(const Clock &other);
    ~Clock();
    void ShowTime();
    void SetTime(int h,int m,int s);
private:
    int hour;
    int minute;
    int second;
};
Clock::Clock(int h,int m,int s)
{
    cout << "Clock(3*int)" << endl;
    hour = h ;
    minute = m;
    second = s;
}
Clock::Clock(const Clock &other)
{
    cout << "Clock(&)" << endl;
    hour = other.hour;
    minute = other.minute;
    second = other.second;
}
Clock::~Clock()
{
    cout << "~Clock()  " << hour <<  endl;
}

void Clock::ShowTime()
{   cout << hour << ":" << minute << ":" << second << endl;  }
void Clock::SetTime(int h,int m,int s)
{   hour = h; minute = m; second = s;   }

//堆区开辟数组
int main()
{
   //执行new时，一定会经历构造的过程
    Clock *p = new Clock[5];  //连续的需要五个这个类型的空间
    delete []p;

    return 0;
}

示例3：

#include <iostream>
using namespace std;

class A
{
public:
    A() {   str = new char[1]; *str = '\0'  };
    ~A() { delete []str;    }
    void Show() {   cout << str << endl;    }
private:
    char *str;
};

int main()
{
    A a1;
    return 0;
}

五、继承

继承是面向对象三大特性之一

有些类与类之间存在特殊的关系，例如下图中：
在这里插入图片描述

我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。
这个时候我们就可以考虑利用继承的技术，减少重复代码

5.1 继承方式：

继承方式一共有三种：

公共继承
保护继承
私有继承

父类-子类   基类-派生类
        parent->:   public          protected           private
    public:         public          protected           -
    protected:      protected       protected           -
    private:        private         private             -

在这里插入图片描述

示例：

#include <iostream>
using namespace std;

class A
{
public:
    A() {cout << "A()" << endl;}
    ~A() {cout << "~A()" << endl;}
    void GetA() {  cout << "A::GetA() " <<  a << endl;}
protected:
    void Show()  {  cout << "A::Show()" <<  a << endl;}
private:
    int a;
};

class B : public A
{
public:
    B() {cout << "B()" << endl;}
    ~B() {cout << "~B()" << endl;}
    void GetShow() { Show();    }
    void GetA() {  cout << "B::GetA() " << endl;}
};

int main()
{
    B tmp;
    tmp.GetA();

    return 0;
}

这篇关于C++初探：qt应用的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

C/C++教程

C++初探：qt应用

一、输入和输出

二、封装

1.1 封装定义-属性和行为

1.2 访问权限

三、类中的特殊函数

3.1 构造函数

3.2 析构函数

3.3 拷贝构造函数

四、C++内存模型

new && delete

五、继承

5.1 继承方式：

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯