DAY8 华清实训（LINUX学习）

最新推荐文章于 2024-07-11 10:51:42 发布

西子实验室--小刘

最新推荐文章于 2024-07-11 10:51:42 发布

阅读量379

点赞数 3

文章标签： linux 学习单片机

本文链接：https://blog.csdn.net/m0_68020464/article/details/139612191

版权

第八天

C++

c++即c plus plus ,创建一个c++文件要使用.cpp后缀，编译时使用g++编译器

面向对象程序设计

C++ 完全支持面向对象的程序设计，包括面向对象开发的四大特性：

封装（Encapsulation） ：封装是将数据和方法组合在一起，对外部隐藏实现细节，只公开对外提供的接口。这样可以提高安全性、可靠性和灵活性。
继承（Inheritance） ：继承是从已有类中派生出新类，新类具有已有类的属性和方法，并且可以扩展或修改这些属性和方法。这样可以提高代码的复用性和可扩展性。
多态（Polymorphism） ：多态是指同一种操作作用于不同的对象，可以有不同的解释和实现。它可以通过接口或继承实现，可以提高代码的灵活性和可读性。
抽象（Abstraction） ：抽象是从具体的实例中提取共同的特征，形成抽象类或接口，以便于代码的复用和扩展。抽象类和接口可以让程序员专注于高层次的设计和业务逻辑，而不必关注底层的实现细节。

标准库

标准的 C++ 由三个重要部分组成：

核心语言，提供了所有构件块，包括变量、数据类型和常量，等等。
C++ 标准库，提供了大量的函数，用于操作文件、字符串等。
标准模板库（STL），提供了大量的方法，用于操作数据结构等。

编译/执行 C++ 程序(windows)

实例

#include <iostream>
using namespace std;
int main()
{
     cout << "Hello, world!" << endl;
     return 0;
}

运行实例 »

你可以用 "\n" 代替以上代码里的 endl。

实例

#include <iostream>
using namespace std;
int main()
{
    cout << "Hello, world!" << "\n";
     return 0;
}

LINUX

g++编译

g++ xxx.cpp

程序 g++ 是将 gcc 默认语言设为 C++ 的一个特殊的版本，链接时它自动使用 C++ 标准库而不用 C 标准库。通过遵循源码的命名规范并指定对应库的名字，用 gcc 来编译链接 C++ 程序是可行的，如下例所示：

$ gcc main.cpp -lstdc++ -o main

下面是一个保存在文件 helloworld.cpp 中一个简单的 C++ 程序的代码：

#include <iostream>using namespace std;int main(){
cout << "Hello, world!" << endl;
return 0;}

最简单的编译方式：

$ g++ helloworld.cpp

由于命令行中未指定可执行程序的文件名，编译器采用默认的 a.out。程序可以这样来运行：

$ ./a.outHello, world!

通常我们使用 -o 选项指定可执行程序的文件名，以下实例生成一个 helloworld 的可执行文件：

$ g++ helloworld.cpp -o helloworld

执行 helloworld:

$ ./helloworld

Hello, world!

如果是多个 C++ 代码文件，如 runoob1.cpp、runoob2.cpp，编译命令如下：

$ g++ runoob1.cpp runoob2.cpp -o runoob

生成一个 runoob 可执行文件。

g++ 有些系统默认是使用 C++98，我们可以指定使用 C++11 来编译 main.cpp 文件：

g++ -g -Wall -std=c++11 main.cpp

C++ 程序结构

让我们看一段简单的代码，可以输出单词 Hello World。

实例

#include <iostream>
using namespace std; // main() 是程序开始执行的地方
int main()
{
cout << "Hello World"; // 输出 Hello World
return 0;
}

接下来我们讲解一下上面这段程序：

C++ 语言定义了一些头文件，这些头文件包含了程序中必需的或有用的信息。上面这段程序中，包含了头文件 <iostream> 。
下一行 using namespace std; 告诉编译器使用 std 命名空间。命名空间是 C++ 中一个相对新的概念。
下一行 // main() 是程序开始执行的地方 是一个单行注释。单行注释以 // 开头，在行末结束。
下一行 int main() 是主函数，程序从这里开始执行。
下一行 cout << "Hello World"; 会在屏幕上显示消息 "Hello World"。
下一行 return 0; 终止 main( )函数，并向调用进程返回值 0。

编译 & 执行 C++ 程序

接下来让我们看看如何把源代码保存在一个文件中，以及如何编译并运行它。下面是简单的步骤：

打开一个文本编辑器，添加上述代码。
保存文件为 hello.cpp。
打开命令提示符，进入到保存文件所在的目录。
键入 'g++ hello.cpp '，输入回车，编译代码。如果代码中没有错误，命令提示符会跳到下一行，并生成 a.out 可执行文件。
现在，键入 ' a.out' 来运行程序。
您可以看到屏幕上显示 ' Hello World '。

$ g++ hello.cpp

$ ./a.outHello World

请确保您的路径中已包含 g++ 编译器，并确保在包含源文件 hello.cpp 的目录中运行它。

您也可以使用 makefile 来编译 C/C++ 程序。

C++ 中的分号 & 语句块

在 C++ 中，分号是语句结束符。也就是说，每个语句必须以分号结束。它表明一个逻辑实体的结束。

例如，下面是三个不同的语句：

x = y; y = y+1; add(x, y);

语句块是一组使用大括号括起来的按逻辑连接的语句。例如：

{ cout << "Hello World";

// 输出 Hello World

return 0; }

C++ 不以行末作为结束符的标识，因此，您可以在一行上放置多个语句。例如：

x = y;

y = y+1;

add(x, y);

等同于

x = y; y = y+1; add(x, y);

C++ 数据类型

使用编程语言进行编程时，需要用到各种变量来存储各种信息。变量保留的是它所存储的值的内存位置。这意味着，当您创建一个变量时，就会在内存中保留一些空间。

您可能需要存储各种数据类型（比如字符型、宽字符型、整型、浮点型、双浮点型、布尔型等）的信息，操作系统会根据变量的数据类型，来分配内存和决定在保留内存中存储什么。

基本的内置类型

C++ 为程序员提供了种类丰富的内置数据类型和用户自定义的数据类型。下表列出了七种基本的 C++ 数据类型：

类型	关键字
布尔型	bool
字符型	char
整型	int
浮点型	float
双浮点型	double
无类型	void
宽字符型	wchar_t

其实 wchar_t 是这样来的：

typedef short int wchar_t;

所以 wchar_t 实际上的空间是和 short int 一样。

一些基本类型可以使用一个或多个类型修饰符进行修饰：

signed
unsigned
short
long

下表显示了各种变量类型在内存中存储值时需要占用的内存，以及该类型的变量所能存储的最大值和最小值。

注意：不同系统会有所差异，一字节为 8 位。

注意：默认情况下，int、short、long都是带符号的，即 signed。

注意：long int 8 个字节，int 都是 4 个字节，早期的 C 编译器定义了 long int 占用 4 个字节，int 占用 2 个字节，新版的 C/C++ 标准兼容了早期的这一设定。

类型	位	范围
char	1 个字节	-128 到 127 或者 0 到 255
unsigned char	1 个字节	0 到 255
signed char	1 个字节	-128 到 127
int	4 个字节	-2147483648 到 2147483647
unsigned int	4 个字节	0 到 4294967295
signed int	4 个字节	-2147483648 到 2147483647
short int	2 个字节	-32768 到 32767
unsigned short int	2 个字节	0 到 65,535
signed short int	2 个字节	-32768 到 32767
long int	8 个字节	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
signed long int	8 个字节	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
unsigned long int	8 个字节	0 到 18,446,744,073,709,551,615
float	4 个字节	精度型占4个字节（32位）内存空间，+/- 3.4e +/- 38 (~7 个数字)
double	8 个字节	双精度型占8 个字节（64位）内存空间，+/- 1.7e +/- 308 (~15 个数字)
long double	16 个字节	长双精度型 16 个字节（128位）内存空间，可提供18-19位有效数字。
wchar_t	2 或 4 个字节	1 个宽字符

注意，各种类型的存储大小与系统位数有关，但目前通用的以64位系统为主。

以下列出了32位系统与64位系统的存储大小的差别（windows 相同）：

从上表可得知，变量的大小会根据编译器和所使用的电脑而有所不同。

下面实例会输出您电脑上各种数据类型的大小。

实例

#include<iostream>
#include <limits>
using namespace std;
int main()
{
     cout << "type: \t\t" << "************size**************"<< endl;
     cout << "bool: \t\t" << "所占字节数：" << sizeof(bool);
     cout << "\t最大值：" << (numeric_limits<bool>::max)();
     cout << "\t\t最小值：" << (numeric_limits<bool>::min)() << endl;
     cout << "char: \t\t" << "所占字节数：" << sizeof(char);
     cout << "\t最大值：" << (numeric_limits<char>::max)();
     cout << "\t\t最小值：" << (numeric_limits<char>::min)() << endl;
     cout << "signed char: \t" << "所占字节数：" << sizeof(signed char);
     cout << "\t最大值：" << (numeric_limits<signed char>::max)();
     cout << "\t\t最小值：" << (numeric_limits<signed char>::min)() << endl;
     cout << "unsigned char: \t" << "所占字节数：" << sizeof(unsigned char);
     cout << "\t最大值：" << (numeric_limits<unsigned char>::max)();
    cout << "\t\t最小值：" << (numeric_limits<unsigned char>::min)() << endl;
     cout << "wchar_t: \t" << "所占字节数：" << sizeof(wchar_t);
     cout << "\t最大值：" << (numeric_limits<wchar_t>::max)();
    cout << "\t\t最小值：" << (numeric_limits<wchar_t>::min)() << endl;
    cout << "short: \t\t" << "所占字节数：" << sizeof(short);
    cout << "\t最大值：" << (numeric_limits<short>::max)();
     cout << "\t\t最小值：" << (numeric_limits<short>::min)() << endl;
     cout << "int: \t\t" << "所占字节数：" << sizeof(int);
     cout << "\t最大值：" << (numeric_limits<int>::max)();
     cout << "\t最小值：" << (numeric_limits<int>::min)() << endl;
     cout << "unsigned: \t" << "所占字节数：" << sizeof(unsigned);
     cout << "\t最大值：" << (numeric_limits<unsigned>::max)();
     cout << "\t最小值：" << (numeric_limits<unsigned>::min)() << endl;
   cout << "long: \t\t" << "所占字节数：" << sizeof(long);
     cout << "\t最大值：" << (numeric_limits<long>::max)();
     cout << "\t最小值：" << (numeric_limits<long>::min)() << endl;
     cout << "unsigned long: \t" << "所占字节数：" << sizeof(unsigned long);
     cout << "\t最大值：" << (numeric_limits<unsigned long>::max)();
     cout << "\t最小值：" << (numeric_limits<unsigned long>::min)() << endl;
     cout << "double: \t" << "所占字节数：" << sizeof(double);
     cout << "\t最大值：" << (numeric_limits<double>::max)();
     cout << "\t最小值：" << (numeric_limits<double>::min)() << endl;
     cout << "long double: \t" << "所占字节数：" << sizeof(long double);
     cout << "\t最大值：" << (numeric_limits<long double>::max)();
     cout << "\t最小值：" << (numeric_limits<long double>::min)() << endl;
     cout << "float: \t\t" << "所占字节数：" << sizeof(float);
     cout << "\t最大值：" << (numeric_limits<float>::max)();
     cout << "\t最小值：" << (numeric_limits<float>::min)() << endl;
     cout << "size_t: \t" << "所占字节数：" << sizeof(size_t);
     cout << "\t最大值：" << (numeric_limits<size_t>::max)();
     cout << "\t最小值：" << (numeric_limits<size_t>::min)() << endl;
     cout << "string: \t" << "所占字节数：" << sizeof(string) << endl;
    // << "\t最大值：" << (numeric_limits<string>::max)() << "\t最小值：" << (numeric_limits<string>::min)() << endl;
    cout << "type: \t\t" << "************size**************"<< endl; return 0; }

本实例使用了 endl，这将在每一行后插入一个换行符，<< 运算符用于向屏幕传多个值，sizeof() 运算符用来获取各种数据类型的大小。

当上面的代码被编译和执行时，它会产生以下的结果，结果会根据所使用的计算机而有所不同：

type: ************size**************

bool: 所占字节数：1 最大值：1 最小值：0

char: 所占字节数：1 最大值：最小值：?

signed char: 所占字节数：1 最大值：最小值：?

unsigned char: 所占字节数：1 最大值：? 最小值：

wchar_t: 所占字节数：4 最大值：2147483647 最小值：-2147483648

short: 所占字节数：2 最大值：32767 最小值：-32768

int: 所占字节数：4 最大值：2147483647 最小值：-2147483648

unsigned: 所占字节数：4 最大值：4294967295 最小值：0

long: 所占字节数：8 最大值：9223372036854775807 最小值：-9223372036854775808

unsigned long: 所占字节数：8 最大值：18446744073709551615 最小值：0

double: 所占字节数：8 最大值：1.79769e+308 最小值：2.22507e-308

long double: 所占字节数：16 最大值：1.18973e+4932 最小值：3.3621e-4932

float: 所占字节数：4 最大值：3.40282e+38 最小值：1.17549e-38

size_t: 所占字节数：8 最大值：18446744073709551615 最小值：0

string: 所占字节数：24

type: ************size**************

typedef 声明

您可以使用 typedef 为一个已有的类型取一个新的名字。下面是使用 typedef 定义一个新类型的语法：

typedef type newname;

例如，下面的语句会告诉编译器，feet 是 int 的另一个名称：

typedef int feet;

现在，下面的声明是完全合法的，它创建了一个整型变量 distance：

feet distance;

枚举类型

枚举类型(enumeration)是C++中的一种派生数据类型，它是由用户定义的若干枚举常量的集合。

如果一个变量只有几种可能的值，可以定义为枚举(enumeration)类型。所谓"枚举"是指将变量的值一一列举出来，变量的值只能在列举出来的值的范围内。

创建枚举，需要使用关键字 enum。枚举类型的一般形式为：

enum 枚举名{

标识符[=整型常数],

标识符[=整型常数],

...

标识符[=整型常数]} 枚举变量;

如果枚举没有初始化, 即省掉"=整型常数"时, 则从第一个标识符开始。

例如，下面的代码定义了一个颜色枚举，变量 c 的类型为 color。最后，c 被赋值为 "blue"。

enum color { red, green, blue } c;

c = blue;

默认情况下，第一个名称的值为 0，第二个名称的值为 1，第三个名称的值为 2，以此类推。但是，您也可以给名称赋予一个特殊的值，只需要添加一个初始值即可。例如，在下面的枚举中，green 的值为 5。

enum color { red, green=5, blue };

在这里，blue 的值为 6，因为默认情况下，每个名称都会比它前面一个名称大 1，但 red 的值依然为 0。

类型转换

类型转换是将一个数据类型的值转换为另一种数据类型的值。

C++ 中有四种类型转换：静态转换、动态转换、常量转换和重新解释转换。

静态转换（Static Cast）

静态转换是将一种数据类型的值强制转换为另一种数据类型的值。

静态转换通常用于比较类型相似的对象之间的转换，例如将 int 类型转换为 float 类型。

静态转换不进行任何运行时类型检查，因此可能会导致运行时错误。

实例

int i = 10;
float f = static_cast<float>(i); // 静态将int类型转换为float类型

动态转换（Dynamic Cast）

动态转换通常用于将一个基类指针或引用转换为派生类指针或引用。动态转换在运行时进行类型检查，如果不能进行转换则返回空指针或引发异常。

实例

class Base {};
class Derived : public Base {};
Base* ptr_base = new Derived;
Derived* ptr_derived = dynamic_cast<Derived*>(ptr_base); // 将基类指针转换为派生类指针

常量转换（Const Cast）

常量转换用于将 const 类型的对象转换为非 const 类型的对象。

常量转换只能用于转换掉 const 属性，不能改变对象的类型。

实例

const int i = 10;
int& r = const_cast<int&>(i); // 常量转换，将const int转换为int

重新解释转换（Reinterpret Cast）

重新解释转换将一个数据类型的值重新解释为另一个数据类型的值，通常用于在不同的数据类型之间进行转换。

重新解释转换不进行任何类型检查，因此可能会导致未定义的行为。

实例

int i = 10;
float f = reinterpret_cast<float&>(i); // 重新解释将int类型转换为float类型

变量： C++ 变量类型 | 菜鸟教程

变量作用域： C++ 变量作用域 | 菜鸟教程

常量： C++ 常量 | 菜鸟教程

运算符： C++ 运算符 | 菜鸟教程

1、C++输出

cout

cout << 输出内容 << endl;
endl :换行

2、强制类型转换

int a =20;
(double)a;--> c语言中的强制类型转换


#include<iostream>
using namespace std;

int main()
{
    double a = 20.14;
    cout << (int)a << endl;
    return 0;
}

3.引用

int a =20;
int &b = a;
b=10;
cout << a << endl;
结果为 10;

4、函数重载 ：函数可以通过传参类型不同，传参顺序不同，传参个数不同

hqyj@ubuntu:~/Desktop/a$ cat -n c.cpp
     1    #include<iostream>
     2    
     3    using namespace std;
     4    
     5    int add(int a,int b)
     6    {
     7      return a+b;
     8    }
     9    
    10    double add(double a,double b)
    11    {
    12     return a+b;
    13    }
    14    
    15    int main()
    16    {
    17        cout << add(12.1,11.1) << endl;
    18        return 0;
    19    }
    20

5、 函数默认参数

函数的形参可以有默认参数，如果调用函数时没有传参，可以使用默认参数

hqyj@ubuntu:~/Desktop/a$ cat -n c.cpp
     1    #include<iostream>
     2    
     3    using namespace std;
     4    
     5    int add(int a,int b=30)
     6    {
     7      return a+b;
     8    }
     9    
    10    double add(double a,double b)
    11    {
    12     return a+b;
    13    }
    14    
    15    int main()
    16    {
    17        cout << add(10) << endl;
    18        return 0;
    19    }
    20

6、类和对象

类是对象的抽象化，对象是类的具象化人类 <----> 某人

类内有权限区域划分，三种：

public:公有，在类内外都可访问

protected ：受保护的，仅可在类内访问

private ：私有权限，仅可在类内访问

C++ 类 & 对象

C++ 在 C 语言的基础上增加了面向对象编程，C++ 支持面向对象程序设计。类是 C++ 的核心特性，通常被称为用户定义的类型。

类用于指定对象的形式，是一种用户自定义的数据类型，它是一种封装了数据和函数的组合。类中的数据称为成员变量，函数称为成员函数。类可以被看作是一种模板，可以用来创建具有相同属性和行为的多个对象。

C++ 类定义

定义一个类需要使用关键字 class，然后指定类的名称，并类的主体是包含在一对花括号中，主体包含类的成员变量和成员函数。

定义一个类，本质上是定义一个数据类型的蓝图，它定义了类的对象包括了什么，以及可以在这个对象上执行哪些操作。

以下实例我们使用关键字 class 定义 Box 数据类型，包含了三个成员变量 length、breadth 和 height：

class Box { public: double length; // 盒子的长度
double breadth; // 盒子的宽度
double height; // 盒子的高度 };

关键字 public 确定了类成员的访问属性。在类对象作用域内，公共成员在类的外部是可访问的。您也可以指定类的成员为 private 或 protected，这个我们稍后会进行讲解。

定义 C++ 对象

类提供了对象的蓝图，所以基本上，对象是根据类来创建的。声明类的对象，就像声明基本类型的变量一样。下面的语句声明了类 Box 的两个对象：

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

对象 Box1 和 Box2 都有它们各自的数据成员。

访问数据成员

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

为了更好地理解这些概念，让我们尝试一下下面的实例：

实例

#include <iostream>
using namespace std;
class Box
{
    public: double length;      // 长度
    double breadth;             // 宽度
    double height;          // 高度
    // 成员函数声明
    double get(void);
void set( double len, double bre, double hei);
};                      // 成员函数定义

double Box::get(void) {
return length * breadth * height;
}
void Box::set( double len, double bre, double hei)
{
    length = len;
    breadth = bre;
    height = hei;
}
int main( )
{
    Box Box1;             // 声明 Box1，类型为 Box
    Box Box2;             // 声明 Box2，类型为 Box
     Box Box3;             // 声明 Box3，类型为 Box
     double volume = 0.0; // 用于存储体积
        // box 1 详述
     Box1.height = 5.0;
     Box1.length = 6.0;
     Box1.breadth = 7.0;         // box 2 详述
     Box2.height = 10.0;
     Box2.length = 12.0;
     Box2.breadth = 13.0;         // box 1 的体积
     volume = Box1.height * Box1.length * Box1.breadth;
     cout << "Box1 的体积：" << volume <<endl; // box 2 的体积
     volume = Box2.height * Box2.length * Box2.breadth;
     cout << "Box2 的体积：" << volume <<endl; // box 3 详述
     Box3.set(16.0, 8.0, 12.0);
     volume = Box3.get();
     cout << "Box3 的体积：" << volume <<endl;
return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Box1 的体积：210
Box2 的体积：1560
Box3 的体积：1536

需要注意的是，私有的成员和受保护的成员不能使用直接成员访问运算符 (.) 来直接访问。我们将在后续的教程中学习如何访问私有成员和受保护的成员。

类 & 对象详解

到目前为止，我们已经对 C++ 的类和对象有了基本的了解。下面的列表中还列出了其他一些 C++ 类和对象相关的概念，可以点击相应的链接进行学习。

概念	描述
类成员函数	类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。
类访问修饰符	类成员可以被定义为 public、private 或 protected。默认情况下是定义为 private。
构造函数 & 析构函数	类的构造函数是一种特殊的函数，在创建一个新的对象时调用。类的析构函数也是一种特殊的函数，在删除所创建的对象时调用。
C++ 拷贝构造函数	拷贝构造函数，是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。
C++ 友元函数	友元函数可以访问类的 private 和 protected 成员。
C++ 内联函数	通过内联函数，编译器试图在调用函数的地方扩展函数体中的代码。
C++ 中的 this 指针	每个对象都有一个特殊的指针 this，它指向对象本身。
C++ 中指向类的指针	指向类的指针方式如同指向结构的指针。实际上，类可以看成是一个带有函数的结构。
C++ 类的静态成员	类的数据成员和函数成员都可以被声明为静态的。

析构函数：

类的析构函数

类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。

析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

下面的实例有助于更好地理解析构函数的概念：

实例

#include <iostream>
using namespace std;
class Line
{
public: void setLength( double len );
    double getLength( void );
    Line(); // 这是构造函数声明
    ~Line(); // 这是析构函数声明
private: double length;
};
// 成员函数定义，包括构造函数
Line::Line(void)
{
cout << "Object is being created" << endl;
}
Line::~Line(void)
{
cout << "Object is being deleted" << endl;
}
void Line::setLength( double len )
{
    length = len;
}
double Line::getLength( void )
{
    return length;
}
// 程序的主函数
int main( )
{
    Line line;
    // 设置长度
    line.setLength(6.0);
     cout << "Length of line : " << line.getLength() <<endl; return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Object is being created

Length of line : 6Object is being deleted

课堂代码：

hqyj@ubuntu:~/Desktop/a$ cat -n c.cpp
     1    #include<iostream>
     2    
     3    using namespace std;                       //库以及流引入
     4    class Demo                                      //定义类
     5    {
     6        public:                                        //setValue函数公有权限声明
     7            void setValue(int value)
     8            {
     9                this->value = value;
    10            }
    11            int getValue();                        //公有函数声明
    12        private:                                        //数值私有权限声明
    13            int value;
    14    };
    15    
    16    int Demo::getValue()                     //类 外部函数定义
    17    {
    18        return value;
    19    }
    20    
    21    int main()
    22    {
    23        Demo mc;                                 //创建类变量
    24        mc.setValue(20);                          //调用类函数
    25        cout << mc.getValue() <<endl;       //输出
    26        return 0;
    27    }

自写代码：

hqyj@ubuntu:~/Desktop/a$ cat -n c.cpp
     1    #include<iostream>
     2    
     3    using namespace std;
     4    
     5    class box
     6    {
     7        public:
     8            int vv(int lenth,int wind, int high);                          //体积函数
     9            int ss(int lenth,int wind,int high);                            //表面积函数
    10    };
    11    
    12    int box::vv(int lenth,int wind,int high)
    13    {
    14        return lenth*wind*high;
    15    };
    16    
    17    int box::ss(int lenth,int wind, int high)
    18    {
    19        int s =2*lenth*wind+2*wind*high+2*lenth*high;
    20        return s;
    21    };
    22    
    23    int main()
    24    {
    25        int l,h,w;
    26        box box1;
    27        cout << "请输入箱子各边长"<<endl;
    28        cout <<"请输入箱子长度"<<endl;
    29        cin >> l;
    30        cout <<"请输入箱子宽度"<<endl;
    31        cin >> w;
    32        cout <<"请输入箱子高度"<<endl;
    33        cin >> h;
    34        cout << "箱子体积为"<<box1.vv(l,w,h) <<endl;
    35        cout << "箱子表面积为"<<box1.ss(l,w,h) <<endl;
    36        return 0;
    37    }
    38

结果：

qyj@ubuntu:~/Desktop/a$ ./cp
请输入箱子各边长
请输入箱子长度
12
请输入箱子宽度
22
请输入箱子高度
1
箱子体积为264
箱子表面积为596

7、构造函数跟析构函数

构造函数名是类名，构造函数会在对象被声明定义时自动执行一次

析构函数的函数名是 ~类名，析构函数会在对象被释放时自动执行一次

Qt

基于C++语言的gui开发框架

新建工程之后会有五个文件

demo1.pro

widget.h

widget.cpp

main.cpp

widget.ui

信号与槽机制：

在Qt的每一个事件都会产生一个信号，而这些信号可以和槽函数相关联；当信号产生时，槽函数执行；这便是信号与槽机制。

QLabel

标签类不可点击

1、可以显示文本

使用setText函数可以设置文本

2、显示图片

可以访问如下网站学习添加资源文件：

三种方式给QT_ 插入图片资源,控件显示图片_如何在qt界面中插入图片代码-CSDN博客