note

一hexo设置

二vsmysql数据库连接(成绩管理系统)

1.概述

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
// 一、MySQL 接口的初始化（构造函数）
   //1、调用mysql_library_init(); 初始化MySQL 官方API库
        //参数:0，后面两个默认（nullptr）如果发生错误，则返回非零值
   // 2、调用mysql_init(); 初始化mysql
        //参数:传入数据库类型的接口变量
         //初始化成功返回nullptr
   // 3、调用mysql_options(); 设置连接选项
        //参数:传入数据库类型的接口变量，MYSQL_SET_CHARSET_NAME ，"数据库名字"
        //作用：将数据库类型的接口变量连接到某个数据库（这里的接口变量相当于实例化变成了对象）
// 二、MySQL 接口的使用 
   //自己包装在了MySQLCAPI类里连接数据库的旗帜函数OpenConn中
   // 4、调用mysql_real_connect(); 连接到MySQL服务器
        //参数:数据库类型的接口变量,数据库IP，数据库用户，密码，数据库名字，port,nullptr，0
        //返回值:连接成功返回nullptr
   //自己将是否成功sql语句包装在了MySQLCAPI类里ExecuteSQL函数和QuerySQL中
   // 5、调用mysql_real_query(); 执行指定的SQL语句
        //参数:接口变量, sql//这里在调用时写sql语句, strlen(sql))
  /*编写MySQLCAPI类里和QuerySQL函数(有返回值的)
    
  */
//三、MySQL 接口的结束关闭（析构函数）
   //自己包装在了MySQLCAPI类里Close函数中
   // 6、调用mysql_close(); 关闭服务器连接
        //参数:传入数据库类型的接口变量(已经实例化成对象)

   // 7、调用mysql_library_end(); 终止MySQL C API库
        //无参数
//四、MySQL的错误信息
   //自己包装在了MySQLCAPI类里 GetErrorinfo函数中
   //8、mysql_errno() //获取错误码
        //参数:传入数据库类型的接口变量
        //返回值:错误码
   //自己包装在了MySQLCAPI类里 GetErrorinfo函数中
   //9、mysql_error() //获取错误信息
        //参数:传入数据库类型的接口变量
        //返回值:错误信息 
//五、调用sql语句注意事项和简单操作方法
    // 1数据库使用latin1 ,latin1_bin
    // 2 字符串传进去只能char类型eg:char name[20];
    //输入用cin接收
    //一、先初始化数据库 MySQLCAPI c_apiconn;//创建数据库连接对象并初始化
    //打开连接c_apiconn.OpenConn("localhost", "root", "1541812541", "db_1");
    //string sql = "use db_1;"; //SQL语句
    //使用数据库c_apiconn.ExecuteSQL(sql.c_str());
    //定义指针char *SQL = (char *)malloc(sizeof(char) * 500);
    //传参数给sql语句sprintf(SQL, "insert into db_1.students values(%d,'%s',%d,%d,%d,%d,%d);", number, name, literature, math, language, science, sum);
     //新建立空的sql语句string sql0 ; 
    //SQL语句赋值给空sql语句变量sql0 = SQL;
    //调用执行函数c_apiconn.ExecuteSQL(sql0.c_str());
    /*查询时使用下面
vector<vector<string>> data;	//保存结果集的容器
c_apiconn.QuerySQL(sql0.c_str(), data);	//调用查询函数
printf("\n");
for (int i = 0; i < data.size(); i++)
{
	for (int j = 0; j < data[i].size(); j++)
	{
		std::cout << data[i][j] << "\t\t";
	}
	std::cout << std::endl;
}*/
    //delete SQL; SQL = NULL;

2.文件

MySQLCAPI.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#pragma once
//包含mysql库的头文件
#include "mysql.h"
//包含mysql链接库
#pragma comment(lib,"libmysql.lib")
#include <string>
#include <vector>
using std::string;
using std::vector;

/*
//最基本的增删查改操作步骤

// 1、调用mysql_library_init(); 初始化MySQL C API库
// 2、调用mysql_init(); 初始化mysql
// 3、调用mysql_options(); 设置连接选项
// 4、调用mysql_real_connect(); 连接到MySQL服务器
// 5、调用mysql_real_query(); 执行指定的SQL语句
// 6、调用mysql_close(); 关闭服务器连接
// 7、调用mysql_library_end(); 终止MySQL C API库
*/
//MySQL接口编写
class MySQLCAPI
{  //1.定义MySQL数据库的数据库类型的接口变量
	MYSQL mysql; 
public:
	int errornum; //错误码
	string errorInfo; //错误信息
public:
	MySQLCAPI();
	~MySQLCAPI();

	// 2.连接数据库的旗帜函数（数据库的ip地址，用户名称，用户密码，数据库名称）
	bool OpenConn(const char * host, const char * username, const char * pwd, const char * dbName, unsigned port = 0);

	//3.获取错误信息函数
	void GetErrorinfo();

	//4.断开数据库
	void Close();

	//5.对数据库的执行操作（无返回值的）
	bool ExecuteSQL(const char * sql);

	//6.对数据库的执行操作（有返回值的）
	//用vector容器（二维，变量的内容给容器）
	bool QuerySQL(const char * sql, vector<vector<string>> &resultSet);

};

MySQLCAPI.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
#include "MySQLCAPI.h"
#include <iostream>
using std::cout;
// 一、MySQL 接口的初始化（构造函数）
   //1、调用mysql_library_init(); 初始化MySQL 官方API库
        //参数:0，后面两个默认（nullptr）如果发生错误，则返回非零值
   // 2、调用mysql_init(); 初始化mysql
        //参数:传入数据库类型的接口变量
         //初始化成功返回nullptr
   // 3、调用mysql_options(); 设置连接选项
        //参数:传入数据库类型的接口变量，MYSQL_SET_CHARSET_NAME ，"数据库名字"
        //作用：将数据库类型的接口变量连接到某个数据库（这里的接口变量相当于实例化变成了对象）
// 二、MySQL 接口的使用 
   //自己包装在了MySQLCAPI类里连接数据库的旗帜函数OpenConn中
   // 4、调用mysql_real_connect(); 连接到MySQL服务器
        //参数:数据库类型的接口变量,数据库IP，数据库用户，密码，数据库名字，port,nullptr，0
        //返回值:连接成功返回nullptr
   //自己将是否成功sql语句包装在了MySQLCAPI类里ExecuteSQL函数和QuerySQL中
   // 5、调用mysql_real_query(); 执行指定的SQL语句
        //参数:接口变量, sql//这里在调用时写sql语句, strlen(sql))
  /*编写MySQLCAPI类里和QuerySQL函数(有返回值的)
    
  */
//三、MySQL 接口的结束关闭（析构函数）
   //自己包装在了MySQLCAPI类里Close函数中
   // 6、调用mysql_close(); 关闭服务器连接
        //参数:传入数据库类型的接口变量(已经实例化成对象)

   // 7、调用mysql_library_end(); 终止MySQL C API库
        //无参数
//四、MySQL的错误信息
   //自己包装在了MySQLCAPI类里 GetErrorinfo函数中
   //8、mysql_errno() //获取错误码
        //参数:传入数据库类型的接口变量
        //返回值:错误码
   //自己包装在了MySQLCAPI类里 GetErrorinfo函数中
   //9、mysql_error() //获取错误信息
        //参数:传入数据库类型的接口变量
        //返回值:错误信息 
//五、调用sql语句注意
    // 1数据库使用latin1 ,latin1_bin
    // 2 字符串传进去只能char类型eg:char name[20];
    //输入用cin接收
    //一、先初始化数据库 MySQLCAPI c_apiconn;//创建数据库连接对象并初始化
    //打开连接c_apiconn.OpenConn("localhost", "root", "1541812541", "db_1");
    //string sql = "use db_1;"; //SQL语句
    //使用数据库c_apiconn.ExecuteSQL(sql.c_str());
    //定义指针char *SQL = (char *)malloc(sizeof(char) * 500);
    //传参数给sql语句sprintf(SQL, "insert into db_1.students values(%d,'%s',%d,%d,%d,%d,%d);", number, name, literature, math, language, science, sum);
     //新建立空的sql语句string sql0 ; 
    //SQL语句赋值给空sql语句变量sql0 = SQL;
    //调用执行函数c_apiconn.ExecuteSQL(sql0.c_str());
    /*查询时使用下面
vector<vector<string>> data;	//保存结果集的容器
c_apiconn.QuerySQL(sql0.c_str(), data);	//调用查询函数
printf("\n");
for (int i = 0; i < data.size(); i++)
{
	for (int j = 0; j < data[i].size(); j++)
	{
		std::cout << data[i][j] << "\t\t";
	}
	std::cout << std::endl;
}*/
    //delete SQL; SQL = NULL;
MySQLCAPI::MySQLCAPI() //MySQL C API库的初始化
{
	// 1、调用mysql_library_init(); 初始化MySQL C API库
	if (mysql_library_init(0, nullptr, nullptr)) //0为成功，如果发生错误，则返回非零值
	{
		std::cout << "初始化MySQL C API库失败！\n";
		getchar();
		exit(1);
	}

	// 2、调用mysql_init(); 在线程安全程序中初始化全局变量和线程处理函数
	if (mysql_init(&mysql) == nullptr) //初始化连接变量
	{
		std::cout << "初始化连接变量失败！\n";
		getchar();
		exit(1);
	}

	// 3、调用mysql_options(); 设置连接选项
	if (mysql_options(&mysql, MYSQL_SET_CHARSET_NAME, "gbk")) //设置连接选项
	{
		std::cout << "设置连接选项失败！\n";
		getchar();
		exit(1);
	}
}


MySQLCAPI::~MySQLCAPI()
{
	// 6、调用mysql_close(); 关闭服务器连接
	Close();

	// 7、调用mysql_library_end(); 终止MySQL C API库
	mysql_library_end();
}

// 连接数据库
bool MySQLCAPI::OpenConn(const char * host, const char * username, const char * pwd, const char * dbName, unsigned port)
{
	// 4、调用mysql_real_connect(); 连接到MySQL服务器
	if (mysql_real_connect(&mysql, host, username, pwd, dbName, port, nullptr, 0) == nullptr)
	{
		std::cout << "连接到MySQL服务器失败！\n";
		GetErrorinfo();
		return false;
	}
	return true;
}

//获取错误信息函数
void MySQLCAPI::GetErrorinfo()
{
	errornum = mysql_errno(&mysql); //获取错误码
	errorInfo = mysql_error(&mysql); //获取错误信息

	cout << "error num:" << errornum << "error Info:" << errorInfo << "\n";
	getchar();
}

//断开数据库
void MySQLCAPI::Close()
{
	// 6、调用mysql_close(); 关闭服务器连接
	mysql_close(&mysql);
}

//执行操作（没有返回结果集）
bool MySQLCAPI::ExecuteSQL(const char * sql)
{
	// 5、调用mysql_real_query(); 执行指定的SQL语句
	if (mysql_real_query(&mysql, sql, strlen(sql)))
	{
		GetErrorinfo();
		return false;
	}
	return true;
}

//查询操作（有返回结果集）
bool MySQLCAPI::QuerySQL(const char * sql, vector<vector<string>> &resultSet)
{
	//1、执行查询语句
	// 5、调用mysql_real_query(); 执行指定的SQL语句
	if (mysql_real_query(&mysql, sql, strlen(sql)))
	{
		GetErrorinfo();
		return false;
	}

	//2、接收查询结果集
	//执行查询语句之后，会产生一个结果集，定义一个数据库对象，用result来调用mysql_store_result来获取结果集
	MYSQL_RES * result = mysql_store_result(&mysql);

	//3、输出二维数组所保存的查询结果集
	//获取二维数组的行数，也就是记录条数
	unsigned int rows = mysql_num_rows(result);

	//获取二维数组的列数，也就是属性个数
	unsigned int fields = mysql_num_fields(result);

	//得到了二维数组的行数和列数之后，就可以遍历数组了
	//获取结果集的行对象，也就是获取记录
	MYSQL_ROW row; //定义一个行数组，用于保存结果集中的一行（一条元组、记录）

	while (row = mysql_fetch_row(result))
	{//调用mysql_fetch_row函数循环遍历结果集result每一条记录
		vector<string> lineDate; //定义一个行数组
		for (int i = 0; i < fields; i++)
		{
			if (row[i]) //row[i] != null
			{
				lineDate.push_back(row[i]);	//数据不为空时，直接把数据放进数组中
			}
			else
			{
				lineDate.push_back("");	//数据为空时，把空字符串""放进数组中
			}
		}
		resultSet.push_back(lineDate); //用二维数组接收行数组的数据
	}
	mysql_free_result(result);	//释放结果集的内存
	return true;
}

Connectest.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#define _CRT_SECURE_NO_WARNINGS
#include "MySQLCAPI.h"
#include <iostream>
using std::cout;
//创建自写类的MySQLCAPI对象并初始化
//打开连接OpenConn
//定义string类型变量的sql语句eg sql（sql语句要有;号）
//定义vector<vector<string>> 变量名eg :data，来保存结果集的容器
//MySQLCAPI对象执行自写类的MySQLCAPI里的QuerySQL语句
//MySQLCAPI对象.QuerySQL(sql语句变量.c_str(),结果集变量名) 
//MySQLCAPI对象执行自写类的MySQLCAPI里的ExecuteSQL语句
//MySQLCAPI对象.ExecuteSQL(sql语句变量.c_str()) 
void connect_test()
{
	MySQLCAPI c_apiconn;	//创建数据库连接对象并初始化

	//打开连接
	c_apiconn.OpenConn("localhost", "root", "1541812541", "sms_db");

	string sql = "use sms_db;"; //SQL语句
	vector<vector<string>> data;	//保存结果集的容器
	c_apiconn.ExecuteSQL(sql.c_str());
	sql = "SELECT * FROM sms_db.班级表;";

	c_apiconn.QuerySQL(sql.c_str(), data);	//调用查询函数

	for (int i = 0; i < data.size(); i++)
	{
		for (int j = 0; j < data[i].size(); j++)
		{
			std::cout << data[i][j] << "\t\t";
		}
		std::cout << std::endl;
	}

	

}
//int main()
//{
//	connect_test();
//	return 0;
//}

grade.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#pragma once
#include<string>
#define _CRT_SECURE_NO_WARNINGS
#include "MySQLCAPI.h"
#include <iostream>
#include<stdio.h>
using namespace std;

class grade
{  //sql = "create database db_n;"; 
	//sql = "use 数据库;";
	//sql = "insert into db_2.student values(null,'小李',1,'男',18);";
	 //sql = "SELECT * FROM sms_db.班级表;";
	//每个考生的相关信息(姓名 + 准证号 + 每科成绩(语、数、外、理综) + 总 分 -- 变量成员
	 //1.获取考生信息(给变量成员赋值) --在类的构造函数中执行
	//2.在终端上打印考生所有信息(main中)
	//打印退出信息。 -- 析构函数
public:
	    char name[20];
		int number;
		int literature;
		int math;
		int language;
		int science;
		int sum;


public:
	grade();
	~grade();
	void grade::grade_Get(void)
	{  
		//一、先初始化数据库 
		MySQLCAPI c_apiconn;//创建数据库连接对象并初始化

		//打开连接
		c_apiconn.OpenConn("localhost", "root", "1541812541", "db_1");
		
		string sql = "use db_1;"; //SQL语句
		c_apiconn.ExecuteSQL(sql.c_str());
		
		printf("请输入准证号:");
		/*scanf("%d", &number);*/
		printf("\n"); 
		cin >> number;
		printf("请输入姓名:");
		/*scanf("%s", name);*/
		printf("\n");
		cin >> name;
		printf("请输入语文成绩:");
		/*scanf("%d", &literature);*/
		printf("\n");
		cin >> literature;
		printf("请输入数学成绩:");
		/*scanf("%d",&math);*/
		printf("\n");
		cin >> math;
		printf("请输入外语成绩:");
		/*scanf("%d", language);*/
		printf("\n");
		cin >> language;
		printf("请输入理综成绩:");
		/*scanf("%d", &science);*/
		cin >> science;
		string sql0 ; //SQL语句
		sum = literature + math + language + science;
		
		char *SQL = (char *)malloc(sizeof(char)* 500);
		sprintf(SQL, "insert into db_1.students values(%d,'%s',%d,%d,%d,%d,%d);", number, name, literature, math, language, science, sum);
		sql0 = SQL;
		c_apiconn.ExecuteSQL(sql0.c_str());
		delete SQL;
		SQL = NULL;
	}

	void grade::grade_Read(void){
		//一、先初始化数据库 
		MySQLCAPI c_apiconn;//创建数据库连接对象并初始化

		//打开连接
		c_apiconn.OpenConn("localhost", "root", "1541812541", "db_1");
		
		string sql = "use db_1;"; //SQL语句
		c_apiconn.ExecuteSQL(sql.c_str());
		printf("请输入查询的姓名:");
		cin >> name;
		string sql1; //SQL语句
		printf("准证号\t    姓名\t    语文成绩\t    数学成绩\t    外语成绩\t    理综成绩\t      总成绩 ");
		char *SQL = (char *)malloc(sizeof(char)* 500);
		
		sprintf(SQL, "select * from db_1.students where name = '%s';", name);
		/*sql = "SELECT * FROM db_1.students;";*/
		sql1 = SQL;
		vector<vector<string>> data;	//保存结果集的容器
		c_apiconn.QuerySQL(sql1.c_str(), data);	//调用查询函数
		printf("\n");
		for (int i = 0; i < data.size(); i++)
		{
			for (int j = 0; j < data[i].size(); j++)
			{
				std::cout << data[i][j] << "\t\t";
			}
			std::cout << std::endl;
		}
		delete SQL;
		SQL = NULL;
		getchar();
		exit(1);
	}
};


grade.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include "grade.h"

//1.获取考生信息(给变量成员赋值) --在类的构造函数中执行
grade::grade()
{ 

	
}

//打印退出信息。 -- 析构函数
grade::~grade()
{
	cout << "谢谢使用高考分数查询系统" << endl;

}

main.h

1
2
3
4
5
#pragma once
#include "grade.h"
#define _CRT_SECURE_NO_WARNINGS
#include "MySQLCAPI.h"
#include <iostream>

main.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include "main.h"
#define _CRT_SECURE_NO_WARNINGS
int main()
{
	printf("---欢迎来到成绩管理系统！---\n\n");
	printf("-- 1--信息录入\n");
	printf("-- 2--成绩查询\n");
	printf("-- 3--退出系统\n");
		grade a;
		//string sql = "use db_1;"; //SQL语句
		int n;
		
		printf("请选择：\n");
		scanf("%d", &n);
	
			system("cls");	//清屏

			switch (n)
			{
			case 1:

				a.grade_Get();

				break;
			case 2:


				printf("---成绩查询---\n");
				a.grade_Read();


				//c_apiconn.QuerySQL(sql.c_str(), data);	//调用查询函数

				//for (int i = 0; i < data.size(); i++)
				//{
				//	for (int j = 0; j < data[i].size(); j++)
				//	{
				//		std::cout << data[i][j] << "\t\t";
				//	}
				//	std::cout << std::endl;
				//};


			case 3:

				break;
			
	}
	return 0;
}

3.需要的包和源码

链接：https://pan.baidu.com/s/1j7kAbSzMUWNzMy-blya49g?pwd=6ph2
提取码：6ph2
具体看视频配置包

三qt sqlite数据库连接(教务系统登录)

1.概述

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//弹出警告对话框头文件
#include <QMessageBox>
//包含数据库
#include <QSqlDatabase>
//对数据库操作的qt的封装
#include <QSqlQuery>
//自写连接数据库函数，函数返回连接成功为true
//！！！对sqlite的某一个数据库操作时，一个程序只能连接一次即1.2.只能一次
//！！！对sqlite的一个以上数据库操作时，需要开辟多对1.2.但仍然一次
//！！！变量尽量都使用QString,需要时转换即可toLocal8Bit()可以转化为vchar
//！！！每次插入都要重新建立表
     //1.实例化一个连接（连接到SQLITE）QSqlDatabase类型
       // QSqlDatabase 实例名字 = QSqlDatabase::addDatabase("QSQLITE");//如果连接了不止一个则QSqlDatabase 实例名字 = QSqlDatabase::addDatabase("QSQLITE","connection1"//自己起的,用来区分是哪个连接);
     //2.(一个程序只能打开一次，不会断)建立数据库或者连接到数据库(已有该数据库则连接到该数据库)
       //实例名字.setDatabaseName("数据库名字"); eg:db1
     //3.判断是否连接成功 (同时会自动打开数据库：所以每次使用必须有)
       //实例对象.open()成功返回true
       //弹出错误提示框QMessageBox::critical(0,"提示标题","错误内容",QMessageBox::Cancel)
     //4.执行sql语句
        //先实例一个QSqlQuery类型的对象 QSqlQuery query;//如果连接了不止一个则QSqlQuery query(要用的数据库实例对象)
        //QSqlQuery类型的对象.exec("sql语句");
      /*创建表create table student (id int primary key, "
               "name varchar(20))
         插入值insert into student values(0, 'LiMing')
         查询:
            QSqlQuery query;
             query.exec("select * from student");
            while(query.next())
          {
           qDebug() << query.value(0).toInt() << query.value(1).toString();
           }
          
	*/

2.简单用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
   //包含
        pro下QT += sql widgets
        #include <QMessageBox>
        #include <QSqlDatabase>
        #include <QSqlQuery>
		#include <QSqlDriver>
        #include <QSqlRecord>
        #include <QSqlField>
        #include <QSqlError>
 // 1.创建一个数据库连接，使用“connection1”为连接名
    QSqlDatabase db1 = QSqlDatabase::addDatabase("QSQLITE", "connection1");
    db1.setDatabaseName("my1.db");
	//如果用mysql加三行db1.setHostName("ip地址"); db1.setUserName("用户名");db1.setPassword("密码"而且addDatabase("QSQLITE"--改为QMYSQL);
    if (!db1.open()) {
        QMessageBox::critical(0, "Cannot open database1",
                              "Unable to establish a database connection.", QMessageBox::Cancel);
        return false;
    }
 //2.// 这里要指定连接
    QSqlQuery query1(db1);
 //3.执行语句
 	01不用传参 
	创建表query1.exec("create table student (id int primary key, name varchar(20))");
    插入表query1.exec("insert into student values(0, 'LiMing')");
	查询表的数据
            QSqlQuery query;
             query.exec("select * from student");
            while(query.next())
          {
           qDebug() << query.value(0).toInt() << query.value(1).toString();
           }
	 更新
    query1.exec("update student set name = 'xiaohong' where id = 20");
      删除
	query1.exec("delete from student where id = 21");
	  02需要传参
	  插入表 一条
     query1.prepare("insert into student (id, password) values (?, ?)");
     QString id = 参数1;
     QString password = 参数;
     query1.addBindValue(id);
     query1.addBindValue(password);
     query1.exec();
	   插入表 一次插入多条
	query1.prepare("insert into student (id, name) values (?, ?)");
     QString id;
     id << 参数 << 参数 << 参数;
     query1.addBindValue(id);
     QString name;
     names << 参数 << 参数 << 参数;
     query1.addBindValue(name);
      以下用到模型需要包含
	  #include <QSqlQueryModel>
      #include <QSqlTableModel>
	  #include <QSqlRelationalTableModel>
	  #include <QTableView>
      #include <QDebug>
	  #include <QMessageBox>
	  #include <QSqlError>
	  #include <QSqlRelationalDelegate>
	   查询表(所有内容)
         QSqlRelationalTableModel *model = new QSqlRelationalTableModel(this);
     model->setTable("表名");
     model->select();
          //model->setEditStrategy(QSqlTableModel::OnManualSubmit);//提交策略可不写，见ppt
      /*显示内容在新的widget上*/
	 QTableView *view = new QTableView(this);
     view->setModel(model);
     setCentralWidget(view);
        查询(过滤型的查看)
	        //在查询表(所有内容)model->select();前加入
      model->setFilter(QString("列的名字 = '%1'").arg(参数-查某列中谁的数据));//找到一行数据，model是个结果集，此时model只有一条数据
	        //获取某行某列数据（某个id对应的密码）
	    /* QString id2 = QString("select password from student where id = '%1'").arg(ui->lineEdit_2->text());
         query2.exec(id2);
            int i =0;
            int a[20];
         while(query2.next())
              {
             // 一个字段
                 i=i+1;
                  a[i] = query2.value(0).toInt();
              }
             i = 0;
           //输出a的所有值
           qDebug() << a[1];
   		*/
	        //可配合
			int rowNum = model->rowCount();//// 获得表的行数
			columnCount()返回一条记录中字段的个数；
			rowCount()返回结果集中记录的条数；
			record()返回第n条记录；
			index()返回指定记录的指定字段的索引；
			clear()可以清空模型中的结果集。
 //4.第二个数据库连接时候上面的1换成2即可
//5.其他操作
      //01 指向索引为1的记录，即第二条记录
    query1.seek(1);
	  //02 返回当前索引值
    qDebug() << "current index: " << query1.at();
	  //03 获取当前行的记录(当前行的所有数据)
    QSqlRecord record = query1.record();
	  //04 获取记录(当前行)中“id”和“name”两个字段的值
    int id = record.value("id").toInt();
    QString name = record.value("name").toString();
    qDebug() << "id: " << id << "name: " << name;
	  //05 获取索引为1的字段，即第二个字段
    QSqlField field = record.field(1);
      //06 输出字段名和字段值，结果为“name”和“MaLiang”
    qDebug() << "second field: " << field.name()
                << "field value: " << field.value().toString();
	  //07 使用QSqlQuery查询连接1的整张表，先要使用连接名获取该连接
        QSqlDatabase db1 = QSqlDatabase::database("connection1");
        QSqlQuery query1(db1);
        qDebug() << "connection1:";
         query1.exec("select * from student");
        while(query1.next())
       {
        qDebug() << query1.value(0).toInt() << query1.value(1).toString();
        }
	  //

3.代码

1.widget.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
#include "widget.h"
#include "ui_widget.h"
#include "QMessageBox"
#include "QString"
#include "string"
#include <QApplication>

Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{
ui->setupUi(this);
   db2 = QSqlDatabase::addDatabase("QSQLITE", "connection2");
    db2.setDatabaseName("my.db");
//    query3.exec("create table student (id QString primary key, password QString");
  //query3.exec("insert into student values('12345', '123')");

}

Widget::~Widget()
{
    delete ui;
}

void Widget::on_pushButton_clicked()
{

    //db2.setDatabaseName("my1.db");
    if (!db2.open()) {
            QMessageBox::critical(0, "Cannot open database1",
                                  "Unable to establish a database connection.", QMessageBox::Cancel);

        }

    QSqlQuery query2(db2);

    QString id2 = QString("select password from student where id = '%1'").arg(ui->lineEdit_2->text());
             query2.exec(id2);
//             query2.exec("select * from student ");
      int i =0;
           int a[20];
           qDebug() << a[1];
         while(query2.next())
              {
            //  两个字段
                    qDebug() << query2.value(0).toInt() << query2.value(1).toInt();
             // 一个字段
                 i=i+1;

                  a[i] = query2.value(0).toInt();
              }
           i = 0;
          // 输出a的所有值
           qDebug() << a[1];
             if(a[1]!=ui->lineEdit_3->text().toInt()){
                 QMessageBox::critical(0, "密码错误",
                                       "请重新登录！", QMessageBox::Ok);
             }
             if(a[1] == ui->lineEdit_3->text().toInt())
             {
                 QString info;//在messagebox显示登录的帐号和密码
                 info += tr("帐号: ");
                 info += ui->lineEdit_2->text( );
                 info += '\n';
              QMessageBox::information(this,tr("登录成功"),info,QMessageBox::Ok);
             }
     }


void Widget::on_pushButton_2_clicked()
{

//    //QSqlDatabase db1 = QSqlDatabase::addDatabase("QSQLITE", "connection2");
//    //db1.setDatabaseName("my1.db");
//    if (!db2.open()) {
//            QMessageBox::critical(0, "Cannot open database1",
//                                  "Unable to establish a database connection.", QMessageBox::Cancel);

//        }
//    QSqlQuery query1(db2);

//    query1.prepare("insert into student (id, password) values (?, ?)");
//    QString id = ui->lineEdit_2->text();
//    QString password = ui->lineEdit_3->text();
//    query1.addBindValue(id);
//    query1.addBindValue(password);
//    query1.exec();

    qDebug()<<"2222222222222\r\n";
        //QSqlDatabase db1 = QSqlDatabase::addDatabase("QSQLITE", "connection2");
        //db1.setDatabaseName("my1.db");
        if (!db2.open()) {
                QMessageBox::critical(0, "Cannot open database1",
                                      "Unable to establish a database connection.", QMessageBox::Cancel);

            }
        QSqlQuery query1(db2);
        //query1.exec("DROP TABLE student");
        //！！！每次插入都要重新建立表
        query1.exec(QObject::tr("create table student (id int primary key, password vchar(40))"));
       //判断插入是否失败
        bool flag  =  query1.prepare("INSERT INTO student (id, password) "
                                    "VALUES (:id, :password)");
        if(flag==false)
        {
            qDebug()<<"插入失败！\r\n";
        }
        QString id = ui->lineEdit_2->text();
        QString password = ui->lineEdit_3->text();
        query1.bindValue(":id",id.toInt());
        query1.bindValue(":password",password.toLocal8Bit());
        query1.exec();


}

2.widget.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QMessageBox>
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QSqlDatabase>
#include <QDebug>
#include <QStringList>
#include <QVariant>
#include <QSqlDriver>
#include <QSqlRecord>
#include <QSqlField>
#include <QSqlError>
#include<QSqlQueryModel>
#include<QTableView>
#include<QAbstractTableModel>
#include<QSqlRelationalTableModel>
namespace Ui {
class Widget;
}

class Widget : public QWidget
{
    Q_OBJECT

public:
    explicit Widget(QWidget *parent = 0);
    ~Widget();
    QSqlDatabase db2;
private slots:
    void on_pushButton_clicked();

    void on_pushButton_2_clicked();

private:
    Ui::Widget *ui;
};

#endif // WIDGET_H

4.需要的包和源码（qt SQlite connecttest）

链接：https://pan.baidu.com/s/1j7kAbSzMUWNzMy-blya49g?pwd=6ph2
提取码：6ph2

三qq通信

思路图

数据库

个人信息表

好友关联表(添加好友自增列)

avatar
one by one
存放个人信息
文章
23
分类
6
Follow Me
公告
This is my Blog
最新文章
深度学习基础编程作业
深度学习基础编程作业
深度学习基础
深度学习基础
GNN
GNN
和弦学习
和弦学习
pytorch基础
pytorch基础
网站资讯
文章数目 :
23
已运行时间 :
本站总字数 :
225.5k
本站访客数 :
本站总访问量 :
最后更新时间 :