2. 程式人生 > >Qt淺談之十六：TCP和UDP（之一）

Qt淺談之十六：TCP和UDP（之一）

阿新 • • 發佈：2019-02-11

一、簡介

       Qt使用QtNetwork模組來進行網路程式設計，提供了一層統一的套接字抽象用於編寫不同層次的網路程式，避免了應用套接字進行網路編的繁瑣（因有時需引用底層作業系統的相關資料結構）。有較底層次的類如QTcpSocket、QTcpServer和QUdpSocket等來表示低層的網路概念；還有高層次的類如QNetworkRequest、QNetworkReply和QNetworkAccessManager使用相同的協議來執行網路操作；也提供了QNetworkConfiguration、QNetworkConfigurationManager和QNetworkSession等類來實現負載管理。

二、分析圖

（1）網路通訊協議

（2）TCP和UDP客戶端和伺服器的建立流程


三、TCP

       TCP是一種可靠的、面向連線、面向資料流的傳輸協議，多數高層網路協議都使用TCP協議，包括HTTP和FTP，TCP協議非常適合資料的連續傳輸。QTcpSocket類為TCP提供了一個介面，繼承自QAbstractSocket。TCP程式設計一般分為客戶端和伺服器端，即C/S（Client/Server）模型。

1、執行圖

伺服器監聽8010埠，客戶端連線。伺服器端接收到連線及其資訊的同時將資訊傳送給所有的客戶端，客戶端顯示獲得的資訊。

2、程式碼

（1）TCP伺服器端（完整程式碼在csdn上）

#include "tcpserver.h"
#include <QApplication>


int main( int argc, char **argv )
{
   	
    QApplication a( argc, argv );
    QTranslator translator(0);
    translator.load("tcpserver_zh",".");
    a.installTranslator(&translator);    
    
    TcpServer *tcpserver = new TcpServer();
    tcpserver->show();
    return a.exec();
}
 
#include "tcpserver.h"

TcpServer::TcpServer( QWidget *parent, Qt::WindowFlags  f )
    : QDialog( parent, f )
{  
    QFont font("ZYSong18030",12);
    setFont(font);
    	
    setWindowTitle(tr("TCP Server"));

    QVBoxLayout *vbMain = new QVBoxLayout( this );

 	ListWidgetContent = new QListWidget( this); 
    vbMain->addWidget( ListWidgetContent );    

    QHBoxLayout *hb = new QHBoxLayout( );
    
    LabelPort = new QLabel( this );
    LabelPort->setText(tr("Port:"));
    hb->addWidget( LabelPort );
   
    LineEditPort = new QLineEdit(this);
    hb->addWidget( LineEditPort );
    
    vbMain->addLayout(hb);
           
    PushButtonCreate = new QPushButton( this);
    PushButtonCreate->setText( tr( "Create" ) );  
    vbMain->addWidget( PushButtonCreate );

    connect(PushButtonCreate,SIGNAL(clicked()),this,SLOT(slotCreateServer()));	

	port = 8010; 
	LineEditPort->setText(QString::number(port)); 

}

TcpServer::~TcpServer()
{
}

void TcpServer::slotCreateServer()                     
{         
	server = new Server(this,port); 
	connect(server,SIGNAL(updateServer(QString,int)),this,SLOT(updateServer(QString,int)));

	PushButtonCreate->setEnabled(false);
}

void TcpServer::updateServer(QString msg,int length)
{
	ListWidgetContent->addItem (msg.left(length) );
}
#include <QtNetwork>


#include "server.h"

Server::Server(QObject *parent,int port)
    : QTcpServer(parent)
{
	listen(QHostAddress::Any,port);
}

void Server::incomingConnection(int socketDescriptor)
{
	TcpClientSocket *tcpClientSocket = new TcpClientSocket(this);
	connect(tcpClientSocket,SIGNAL(updateClients(QString,int)),this,SLOT(updateClients(QString,int)));
	connect(tcpClientSocket,SIGNAL(disconnected(int)),this,SLOT(slotDisconnected(int)));
	
    tcpClientSocket->setSocketDescriptor(socketDescriptor);

	tcpClientSocketList.append(tcpClientSocket);

}

void Server::updateClients(QString msg,int length)
{
	emit updateServer(msg,length);

	for(int i=0;i<tcpClientSocketList.count();i++)
	{
		QTcpSocket *item=tcpClientSocketList.at(i);
    	if(item->write(msg.toLatin1(), length)!=length)
    	{
    		continue ;
    	}	
	}
}

void Server::slotDisconnected(int descriptor)
{
	for(int i=0;i<tcpClientSocketList.count();i++)
	{
		QTcpSocket *item=tcpClientSocketList.at(i);
    	if(item->socketDescriptor ()==descriptor)
    	{
    		tcpClientSocketList.removeAt(i);
    		return;
    	}	
	}	
	return;
}
#include "tcpserver.h"

TcpClientSocket::TcpClientSocket( QObject *parent)
{  
    connect(this, SIGNAL(readyRead()),this, SLOT(dataReceived()));	 
    connect(this, SIGNAL(disconnected()),this, SLOT(slotDisconnected()));
}

TcpClientSocket::~TcpClientSocket()
{
}
                                                                             
void TcpClientSocket::dataReceived()
{
    while (bytesAvailable()>0) 
    {
 		char buf[1024];
 		int length=bytesAvailable();
 		read(buf, length);

		QString msg=buf;
		
		emit updateClients(msg,length);
    }	
}

void TcpClientSocket::slotDisconnected()
{
	emit disconnected(this->socketDescriptor ());
}
（2）TCP客戶端 
#include "tcpclient.h"

TcpClient::TcpClient( QWidget *parent, Qt::WindowFlags  f )
    : QDialog( parent, f )
{  
    QFont font("ZYSong18030",12, QFont::Normal);
    setFont(font);
    	
    setWindowTitle(tr("TCP Client"));

    QVBoxLayout *vbMain = new QVBoxLayout( this );
    
 	ListWidgetContent = new QListWidget( this); 
    vbMain->addWidget( ListWidgetContent ); 
    
	QHBoxLayout *hb1 = new QHBoxLayout( );
	  
    LineEditSend = new QLineEdit(this);
    hb1->addWidget( LineEditSend );	

    PushButtonSend = new QPushButton( this);
    PushButtonSend->setText( tr( "Send" ) );  
    hb1->addWidget( PushButtonSend );

	vbMain->addLayout( hb1 );

    QHBoxLayout *hb2 = new QHBoxLayout( );

    LabelUser = new QLabel( this );
    LabelUser->setText(tr("User Name:"));
    hb2->addWidget( LabelUser );
   
    LineEditUser = new QLineEdit(this);
    hb2->addWidget( LineEditUser );

	QHBoxLayout *hb3 = new QHBoxLayout( );

    LabelServerIP = new QLabel( this );
    LabelServerIP->setText(tr("Server:"));
    hb3->addWidget( LabelServerIP );
   
    LineEditServerIP = new QLineEdit(this);
    hb3->addWidget( LineEditServerIP );
    
    QHBoxLayout *hb4 = new QHBoxLayout( );
    
    LabelPort = new QLabel( this );
    LabelPort->setText(tr("Port:"));
    hb4->addWidget( LabelPort );
   
    LineEditPort = new QLineEdit(this);
    hb4->addWidget( LineEditPort );
    
    vbMain->addLayout(hb2);
    vbMain->addLayout(hb3);
    vbMain->addLayout(hb4);
           
    PushButtonEnter = new QPushButton( this);
    PushButtonEnter->setText( tr( "Enter" ) );  
    vbMain->addWidget( PushButtonEnter );

    connect(PushButtonEnter,SIGNAL(clicked()),this,SLOT(slotEnter()));
    connect(PushButtonSend,SIGNAL(clicked()),this,SLOT(slotSend()));	

	serverIP = new QHostAddress();
	port = 8010; 
	LineEditPort->setText(QString::number(port)); 
	
	status=false;
	
	PushButtonSend->setEnabled( false ); 
}

TcpClient::~TcpClient()
{
}
                                                                             
void TcpClient::slotEnter()                     
{         
	if(!status)
	{
		QString ip=LineEditServerIP->text();
		if(!serverIP->setAddress(ip))
		{
			QMessageBox::information(this,tr("error"),tr("server ip address error!"));
			return;
		}
		if(LineEditUser->text()=="")
		{
			QMessageBox::information(this,tr("error"),tr("User name error!"));
			return ;
		}	
		userName=LineEditUser->text();
		tcpSocket = new QTcpSocket(this);
		connect(tcpSocket,SIGNAL(connected()),this,SLOT(slotConnected()));
		connect(tcpSocket,SIGNAL(disconnected()),this,SLOT(slotDisconnected()));
		connect(tcpSocket, SIGNAL(readyRead()),this, SLOT(dataReceived()));
		
		tcpSocket->connectToHost ( *serverIP, port);
		
		status=true;
	}
	else
	{
		int length = 0; 
		
		QString msg=userName+tr(":Leave Chat Room");
	    if((length=tcpSocket->write(msg.toLatin1(),msg.length()))!=msg.length())
	    {
	    	return ;
	    }			
		tcpSocket->disconnectFromHost();
		
		status=false;
	}
	
}

void TcpClient::slotConnected()                     
{
	int length = 0; 
	PushButtonSend->setEnabled( true );
	PushButtonEnter->setText(tr("Leave"));
	QString msg=userName+tr(":Enter Chat Room");
    if((length=tcpSocket->write(msg.toLatin1(),msg.length()))!=msg.length())
    {
    	return ;
    }	
}

void TcpClient::slotDisconnected()                     
{
	PushButtonSend->setEnabled( false );
	PushButtonEnter->setText(tr("Enter"));
}

void TcpClient::slotSend()                     
{         
	if(LineEditSend->text()=="")
	{
		return ;
	}
	
	QString msg=userName+":"+LineEditSend->text();
	
	tcpSocket->write(msg.toLatin1(),msg.length());
	LineEditSend->clear();
}

void TcpClient::dataReceived()
{
    while (tcpSocket->bytesAvailable()>0) 
    {
 		QByteArray datagram;
 		datagram.resize(tcpSocket->bytesAvailable());
 		QHostAddress sender;


 		tcpSocket->read(datagram.data(), datagram.size());

		QString msg=datagram.data();
	
		ListWidgetContent->addItem (msg.left(datagram.size()));
    }

}

3、其他TCP伺服器和客戶端程式碼

（1）TCP伺服器——基本模式

#ifndef SERVER_H
#define SERVER_H

#include <QObject>
#include <QTcpServer>

class server : public QObject
{
    Q_OBJECT
public:
    explicit server(QObject *parent = 0);

private:
    QTcpServer *tcpServer;
    QTcpSocket *clientConnection;

signals:

public slots:
    void sendMessage();
    void on_Ready_Read();
};

#endif // SERVER_H
#include <QTcpSocket>
#include "server.h"


server::server(QObject *parent) :
    QObject(parent)
{
    tcpServer = new QTcpServer(this);
    // 使用了IPv4的本地主機地址，等價於QHostAddress("127.0.0.1")
    if (!tcpServer->listen(QHostAddress::Any, 59769)) {
        qDebug() << tcpServer->errorString();
    }
    connect(tcpServer, SIGNAL(newConnection()), this, SLOT(sendMessage()));
}

void server::sendMessage()
{
    clientConnection = tcpServer->nextPendingConnection();
    clientConnection->write("hello client\r\n");
    clientConnection->flush();   
    clientConnection->waitForBytesWritten(3000);
    connect(clientConnection, SIGNAL(readyRead()), this, SLOT(on_Ready_Read())); 
    connect(clientConnection, SIGNAL(disconnected()), clientConnection, SLOT(deleteLater()));
}
void server::on_Ready_Read()
{ 
    QByteArray block = clientConnection->readAll(); 
    qDebug() << "server = " << block; 
    QString commandXml = QString("<event>" " <object>USER</object>" " <action>LOGINSUCCESS</action>" " <data>" " </data>" "</event>"); 
    QByteArray data = commandXml.toUtf8(); 
    QString str = QString("%1:%2,").arg(data.size()).arg(QString::fromUtf8(data)); 
    clientConnection->write(str.toUtf8()); clientConnection->disconnectFromHost();
}

（2）TCP伺服器——執行緒處理

#ifndef MYSERVER_H
#define MYSERVER_H

#include <QTcpServer>
#include <QDebug>
#include "mythread.h"

class MyServer : public QTcpServer
{
    Q_OBJECT
public:
    explicit MyServer(QObject *parent = 0);
    void StartServer();

protected:
    void incomingConnection(int  socketDescriptor);
signals:

public slots:

};

#endif // MYSERVER_H

#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QThread>
#include <QTcpSocket>
#include <QDebug>

class MyThread : public QThread
{
    Q_OBJECT
public:
    explicit MyThread(int ID, QObject *parent = 0);
    void run();

signals:
    void error(QTcpSocket::SocketError socketerror);

public slots:
    void readyRead();
    void disconnected();

private:
    QTcpSocket *socket;
    int socketDescriptor;

};
#endif // MYTHREAD_H
#include <QCoreApplication>
#include "myserver.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    MyServer server;
    server.StartServer();

    return a.exec();
}

#include "myserver.h"

MyServer::MyServer(QObject *parent) :
    QTcpServer(parent)
{
}

void MyServer::StartServer()
{
    if (!listen(QHostAddress::Any, 1234)) {
        qDebug() << "Could not start server";
    }
    else {
        qDebug() << "Listening...";
    }
}

void MyServer::incomingConnection(int socketDescriptor)
{
    qDebug() << socketDescriptor << ":connecting...";
    MyThread *thread = new MyThread(socketDescriptor, this);
    connect(thread, SIGNAL(finished()), this, SLOT(deleteLater()));
    thread->start();
}

#include "mythread.h"

MyThread::MyThread(int ID, QObject *parent) :
    QThread(parent)
{
    socketDescriptor = ID;
}


void MyThread::run()
{
   //thread starts here
    qDebug() << socketDescriptor << ":starting thread";
    socket = new QTcpSocket;
    if (!socket->setSocketDescriptor(socketDescriptor)) {
        emit error(socket->error());
        return;
    }
    connect(socket, SIGNAL(readyRead()), this, SLOT(readyRead()), Qt::DirectConnection);
    connect(socket, SIGNAL(disconnected()), this, SLOT(disconnected()), Qt::DirectConnection);
    qDebug() << socketDescriptor << ":client connected!";
    exec();
}
void MyThread::readyRead()
{
    QByteArray Data = socket->readAll();
    qDebug() << socketDescriptor << ":Data in:" << Data;
    socket->write(Data);
}
void MyThread::disconnected()
{
    qDebug() << socketDescriptor << ":Disconnected!";
    socket->deleteLater();
    exit(0);
}

（3）TCP伺服器——執行緒池

#ifndef MYSERVER_H
#define MYSERVER_H

#include <QTcpServer>
#include <QThreadPool>
#include <QDebug>
#include "myrunnable.h"

class MyServer : public QTcpServer
{
    Q_OBJECT
public:
    explicit MyServer(QObject *parent = 0);
    void StartServer();

protected:
    void incomingConnection(int handle);

private:
    QThreadPool *pool;

signals:

public slots:

};

#endif // MYSERVER_H

#ifndef MYRUNNABLE_H
#define MYRUNNABLE_H

#include <QRunnable>
#include <QTcpSocket>
#include <QDebug>

class MyRunnable : public QRunnable
{
public:
    MyRunnable();
    int SocketDescriptor;

protected:
    void run();
};

#endif // MYRUNNABLE_H

#include "myserver.h"

MyServer::MyServer(QObject *parent) :
    QTcpServer(parent)
{
    pool = new QThreadPool(this);
    pool->setMaxThreadCount(5);
}
void MyServer::StartServer()
{
    if (listen(QHostAddress::Any, 1234)) {
        qDebug() << "Server started!";
    }
    else {
        qDebug() << "Server did not start!";
    }
}
void MyServer::incomingConnection(int handle)
{
    MyRunnable *task = new MyRunnable();
    task->setAutoDelete(true);
    task->SocketDescriptor = handle;
    pool->start(task);
}

#include "myrunnable.h"

MyRunnable::MyRunnable()
{
}

void MyRunnable::run()
{
    if (!SocketDescriptor)  return;

    QTcpSocket socket;
    socket.setSocketDescriptor(SocketDescriptor);

    socket.write("hello world\r\n");
    socket.flush();
    socket.waitForBytesWritten();
    socket.close();
}

#include <QCoreApplication>
#include "myserver.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    MyServer Server;
    Server.StartServer();
    return a.exec();
}

（4）TCP伺服器——高階非同步方式並使用執行緒池

儘可能理解這種方式，效率相對比較客觀。執行結果：


#ifndef MYSERVER_H
#define MYSERVER_H

#include <QTcpServer>
#include <QTcpSocket>
#include <QAbstractSocket>
#include "myclient.h"

class MyServer : public QTcpServer
{
    Q_OBJECT
public:
    explicit MyServer(QObject *parent = 0);
    void StartServer();

protected:
    void incomingConnection(int handle);

signals:

public slots:

};

#endif // MYSERVER_H

#ifndef MYCLIENT_H
#define MYCLIENT_H

#include <QObject>
#include <QTcpSocket>
#include <QDebug>
#include <QThreadPool>
#include "mytask.h"

class MyClient : public QObject
{
    Q_OBJECT
public:
    explicit MyClient(QObject *parent = 0);
    void SetSocket(int Descriptor);

signals:

public slots:
    void connected();
    void disconnected();
    void readyRead();
    void TaskResult(int Number);

private:
    QTcpSocket *socket;
};

#endif // MYCLIENT_H

#ifndef MYTASK_H
#define MYTASK_H

#include <QRunnable>
#include <QDebug>

class MyTask : public QObject, public QRunnable
{
    Q_OBJECT
public:
    MyTask();

signals:
    void Result(int Number);

protected:
    void run();
};

#endif // MYTASK_H

#include "myserver.h"

MyServer::MyServer(QObject *parent) :
    QTcpServer(parent)
{
}
void MyServer::StartServer()
{
    if (listen(QHostAddress::Any, 1234)) {
        qDebug() << "Server started!";
    }
    else {
        qDebug() << "Server did not start!";
    }
}

void MyServer::incomingConnection(int handle)
{
    MyClient *client = new MyClient(this);
    client->SetSocket(handle);
}

#include "myclient.h"

MyClient::MyClient(QObject *parent) :
    QObject(parent)
{
    QThreadPool::globalInstance()->setMaxThreadCount(15);
}

void MyClient::SetSocket(int Descriptor)
{
    socket = new QTcpSocket(this);

    connect(socket, SIGNAL(connected()), this, SLOT(connected()));
    connect(socket, SIGNAL(disconnected()), this, SLOT(disconnected()));
    connect(socket, SIGNAL(readyRead()), this, SLOT(readyRead()));

    socket->setSocketDescriptor(Descriptor);
    qDebug() << "client connected";
}

void MyClient::connected()
{
    qDebug() << "client connected event";
}

void MyClient::disconnected()
{
    qDebug() << "client disconnected";
}

void MyClient::readyRead()
{
    qDebug() << socket->readAll();
    //Time Consumer
    MyTask *mytask = new MyTask;
    mytask->setAutoDelete(true);
    connect(mytask, SIGNAL(Result(int)), this, SLOT(TaskResult(int)));
    QThreadPool::globalInstance()->start(mytask);
}

void MyClient::TaskResult(int Number)
{
    //right here
    QByteArray Buffer;
    Buffer.append("\r\nTask Result = ");
    Buffer.append(QString::number(Number));

    socket->write(Buffer);
}

#include "mytask.h"

MyTask::MyTask()
{
}

void MyTask::run()
{
    //time consumer
    qDebug() << "Task Start";
    int iNumber = 0;
    for (int i = 0; i < 100; i++) {
        iNumber += i;
    }
    qDebug() << "Task Done";

    emit Result(iNumber);
}


#include <QCoreApplication>
#include "myserver.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    MyServer Server;
    Server.StartServer();

    return a.exec();
}

（5）TCP客戶端——非同步等待

#ifndef SOCKETTEST_H
#define SOCKETTEST_H

#include <QObject>
#include <QTcpSocket>

class SocketTest : public QObject
{
    Q_OBJECT
public:
    explicit SocketTest(QObject *parent = 0);
    void Connect();

private:
    QTcpSocket *socket;

signals:

public slots:

};

#endif // SOCKETTEST_H
#include "sockettest.h"

SocketTest::SocketTest(QObject *parent) :
    QObject(parent)
{
}

void SocketTest::Connect()
{
    socket = new QTcpSocket(this);
    socket->connectToHost("203.116.165.138", 80);

    if (socket->waitForConnected(3000)) {
        qDebug() << "connected!";

        //send
        socket->write("hello server\r\n\r\n\r\n");
        socket->waitForBytesWritten(1000);
        socket->waitForReadyRead(3000);
        qDebug() << "Reading:" << socket->bytesAvailable();

        qDebug() << socket->readAll();

        socket->close();
    }
    else {
        qDebug() << "not connected!";
    }
}
（6）TCP客戶端——訊號槽連線
#include <QCoreApplication>
#include <QTextCodec>
#include "sockettest.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    QTextCodec *codec = QTextCodec::codecForName("System");
    QTextCodec::setCodecForLocale(codec);
    QTextCodec::setCodecForCStrings(codec);
    QTextCodec::setCodecForTr(codec);
    SocketTest mTest;
    mTest.Test();
    return a.exec();
}

#ifndef SOCKETTEST_H
#define SOCKETTEST_H

#include <QObject>
#include <QDebug>
#include <QTcpSocket>
#include <QAbstractSocket>

class SocketTest : public QObject
{
    Q_OBJECT
public:
    explicit SocketTest(QObject *parent = 0);
    void Test();

private:
    QTcpSocket *socket;

signals:

public slots:
    void connected();
    void disconnected();
    void bytesWritten(qint64 bytes);
    void readyRead();
    void displayError(QAbstractSocket::SocketError);
};

#endif // SOCKETTEST_H

#include "sockettest.h"

SocketTest::SocketTest(QObject *parent) :
    QObject(parent)
{
}

void SocketTest::Test()
{
    socket = new QTcpSocket(this);
    connect(socket, SIGNAL(connected()), this, SLOT(connected()));
    connect(socket, SIGNAL(disconnected()), this, SLOT(disconnected()));
    connect(socket, SIGNAL(bytesWritten(qint64)), this, SLOT(bytesWritten(qint64)));
    connect(socket, SIGNAL(readyRead()), this, SLOT(readyRead()));
    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(displayError(QAbstractSocket::SocketError)));

    qDebug() << "connecting...";
    socket->connectToHost("203.116.165.139", 80);

    if (!socket->waitForConnected(1000)) {
        qDebug() << "Error:" << socket->errorString();
    }
}

void SocketTest::connected()
{
    qDebug() << "connected!";
    socket->write("HEAD / HTTP/1.0\r\n\r\n\r\n");
}

void SocketTest::disconnected()
{
    qDebug() << "disconnected!";
    socket->disconnectFromHost();
}

void SocketTest::bytesWritten(qint64 bytes)
{
    qDebug() << "we wrote:" << bytes;
}

void SocketTest::readyRead()
{
    qDebug() << "reading...";
    qDebug() << socket->readAll();
}
void SocketTest::displayError(QAbstractSocket::SocketError)
{
    qDebug() << socket->errorString();
}

四、TCP總結

      以上各節程式碼均可單獨採用實現伺服器和客戶端的執行，可以選擇設計自己的模式。

      TCP伺服器的效率還取決於使用者設計的模式，好的設計能可以容錯、快速處理大批量的任務、減小系統的負荷、節約記憶體等好處，因此不停的總結TCP的程式碼，並在其基礎上提高是很有必要的。

【待續UDP】

相關推薦

Qt淺談之十六：TCP和UDP（之一）

一、簡介        Qt使用QtNetwork模組來進行網路程式設計，提供了一層統一的套接字抽象用於編寫不同層次的網路程式，避免了應用套接字進行網路編的繁瑣（因有時需引用底層作業系統的相關資料結構）。有較底層次的類如QTcpSocket、QTcpServer和QUdp

Qt淺談之十二：拖拽文字圖片

一、簡介        首先選擇窗體顯示風格，接著顯現拖拽效果，文字和圖示都可以作為拖拽的物件，在窗體中的文字圖示可以拖拽到視窗的任意位置，它們在兩個獨立執行的程式間也可相互拖拽（此時是複製一份到拖拽目的程式視窗中），文字拖拽的範圍更廣（須注意字符集的轉換）。本文解決這種

設計模式之十八：橋接模式（Bridge）

ora 它的 pla sin string src ams down ng- 橋接模式： 將抽象部分和它的實現部分相分離開來，以使它們能夠單獨地變化。 UML圖： 主要包含： Abstraction:定義了抽象部分的接口。操作一個實現部分對

《Javascript權威指南》學習筆記之十七：BOM新成就（1）--client存儲數據（Storage實現）

globals 機制 ng- url new onclick views watermark -c 版權聲明：本文為博主原創文章。未經博主同意不得轉載。 https://blog.csdn

通俗易懂理解TCP和UDP（轉）

建立 休息 如果 str 否則 無連接 一分鐘 tis 得到 知乎看到一位大牛“車小胖”的類比很貼切，就轉過來了。 原文鏈接：https://www.zhihu.com/question/51388497 或者：https://daily.zhihu.com/story/9

Qt淺談之二十一log調試日誌

gms 生成文件 _file__ ica 沒有 rest delet mar 排除 一、簡單介紹 近期因調試code時，想了解程序的流程，但苦於沒有一個簡易的日誌記錄，不停使用qDebug打印輸出，而終於提交代碼時得去多次刪除信息打印，有時還會出現新改動

Qt淺談之四十八視窗下方彈出提示資訊

一、簡介       在專案中一般都會彈出新的子對話方塊顯示提示資訊，但對於一些因後臺資料變化引發的提示還是在視窗下方彈出提示資訊比較合理。點選按鈕彈出提示資訊，當滑鼠放在提示資訊對話方塊上時，暫停動畫可長時間檢視提示資訊。 二、詳解 1、程式碼 （1）fader

Qt淺談之三十二二維碼條形碼解析

一、簡介         二維條碼/二維碼（2-dimensional bar code）是用某種特定的幾何圖形按一定規律在平面（二維方向上）分佈的黑白相間的圖形記錄資料符號資訊的，其應用廣泛，如：產品防偽/溯源、廣告推送、網站連結、資料下載、商品交易、定位/導航、電子憑

Qt淺談之五十一QT_OpenGL

一、簡介           最近想了解些Qt的OpenGL程式設計，可能以後會使用。Opengl是對2D和3D圖形支援很好，有非常多的優化函式，而且是個跨平臺的開源庫。Qt的Opengl封裝的很好，通過Qt的QGLWidget類，將opengl的函式和Qt的介面結合了

Qt淺談之五十介面自定義

一、簡介       Qt自帶的介面不利於樣式的調整和美化，自定義介面便於設計風格。 二、詳解 1、程式碼 （1）pagenumbercontrol.h #ifndef PAGENUMBERCONTROL_H #define PAGENUMBERCONTROL_H

Qt淺談之二十五2048遊戲（原始程式碼來自網路）

一、簡介         Qt改寫2048遊戲，在linux系統下找尋android的視覺效果。 二、執行圖         啟動執行圖： 三、詳解 1、程式碼 （1）widget.h #ifndef WIDGET_H #define WIDGET_H #inclu

Qt淺談之四十一QLineEdit的新樣式和補全歷史記錄

一、簡介        利用背景圖片設計出QLineEdit新的樣式，起到美化介面的效果，並增加自動補全歷史記錄的功能，就可以作為一個完整的庫。  二、詳解 1、知識點 （1）切換QLineEdit的背景 void InnerLineEdit::setNormal()

Qt淺談之二十一log除錯日誌

一、簡介       最近因除錯code時，想了解程式的流程，但苦於沒有一個簡易的日誌記錄，不停使用qDebug列印輸出，而最終提交程式碼時得去多次刪除列印資訊，有時還會出現新修改的程式碼分不清是哪些部分。而使用#ifdef _DEBUG又比較煩這套，因此寫了些簡單的日誌

Qt淺談之二十八解析XML檔案

一、簡介         QtXml模組提供了一個讀寫XML檔案的流，解析方法包含DOM和SAX。DOM（Document ObjectModel）：將XML檔案表示成一棵樹，便於隨機訪問其中的節點，但消耗記憶體相對多一些。SAX（Simple APIfor XML）：一

Qt淺談之二十二Qt樣式表

一、簡介       不斷總結好的樣式表，美化自己的介面（在實際工作中會不斷的更新）。 二、詳解 1、載入樣式表文件 QFile file(":/qss/stylesheet.qss"); file.open(QFile::ReadOnly); QString sty

Qt淺談之四十Centos下Qt結合v4l2實現的視訊顯示

一、簡介        v4l2是針對uvc免驅usb裝置的程式設計框架，主要用於採集usb攝像頭。 可從網上下載最新的原始碼（包括v4l2.c和v4l2.h兩個檔案），本文中修改過。       Qt執行介面如下（動態變化的）： 二、詳解 1、準備 （1）插入usb攝

轉：【Java並發編程】之十六：深入Java內存模型——happen-before規則及其對DCL的分析（含代碼）

無需 bit 對象引用 說了 final 緩存 機器 通過 round 轉載請註明出處：http://blog.csdn.net/ns_code/article/details/17348313 happen—before規則介紹 Java語言中有一個“先行發生

skyfans之每天一個Liunx命令系列之十六：id

截止到上一章，我們終於學完了PERFORMANCE MONITORING AND STATISTICS（效能監測與統計）的命令。 那今天我們來學習什麼類的命令呢，那就是USER INFORMATION AND MANAGEMENT（使用者資訊和管理），今天學習的是什麼命令呢，那就是id（顯示

shell淺談之十一別名、列表及陣列

一、簡介 Shell中別名可以對命令進行重新命名，方便使用者記憶長命名和定製自己熟悉的工作環境；列表是一組命名以邏輯與、邏輯或的關係串在一起，實現指令碼程式的邏輯控制；陣列是一重點，涉及陣列的賦值、操作和字串的處理，以及利用陣列實現堆疊和二維陣列等資料結構的儲存。 二、

Java併發程式設計系列之十六：Lock鎖

Lock鎖簡介 Lock鎖機制是JDK 5之後新增的鎖機制，不同於內建鎖，Lock鎖必須顯式宣告，並在合適的位置釋放鎖。Lock是一個介面，其由三個具體的實現：ReentrantLock、ReetrantReadWriteLock.ReadLock 和 Ree