ICode9

精准搜索请尝试: 精确搜索
首页 > 编程语言> 文章详细

C++初探:qt应用

2021-09-22 19:33:56  阅读:28  来源: 互联网

标签:qt Clock int void cout C++ 函数 初探 构造函数


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或多),可无参

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

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

代码演示:

#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 析构函数

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

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

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

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

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

代码演示:

#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;
}

标签:qt,Clock,int,void,cout,C++,函数,初探,构造函数
来源: https://blog.csdn.net/weixin_51627897/article/details/120421306

专注分享技术,共同学习,共同进步。侵权联系[admin#icode9.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有