Sistema de gestión de bibliotecac
La cantidad de programación es muy grande
El núcleo es la consulta
Entonces, según su pregunta, publicaré un programa de consulta. El nivel de escritura es limitado.
#pragma once // V3.0.155591.61118002
///////////////. ///////// //////////////////////////////
//Contenido: La definición del tipo de clase de fila de CLibrary
//Nombre: CLibrary_rowtype
class CLibrary_rowtype {
public:
long m_iSuffix; sufijo 1
long m_logNumber; //Número de inicio de sesión 2
std::string m_BookName; //Nombre del libro. string m_AuthName; //Nombre del autor 4 (i )
std:: string m_CategoryName; //Número de categoría 5
std:: string m_PublishCompanyName; //Unidad de publicación
long m_PublishTime; //Tiempo de publicación
long m_Price; //Precio
public:
CLibrary_rowtype()
{
m_iSuffix = 0 ;
m_logNumber = 0;
m_BookName = "";
m_AuthName = "";
m_CategoryName = "";
p>
m_PublishCompanyName = "";
m_PublishTime = 0
m_Price = 0; >
}
virtual ~CLibrary_rowtype (){;}
público:
////////////// //////////////// /////////////////////////////////// /////Función: GetCol_iSuffix
//Efecto: obtener referencia de col. col es iSuffix
//Retorno: long amp
long amp; ; GetCol_iSuffix(void)
{
return m_iSuffix;
}
//////////// /////////////// //////////////////////////////////// ///Función: GetCol_BookName
//Efecto: obtener la referencia de la col. es BookName
//Re
girar: std:: amplificador de cadena
std:: amplificador de cadena GetCol_BookName(void)
{
return m_BookName; }
/////////////////////////////////////////// // //////////////////////////////////Función: GetCol_AuthName
//Efecto: obtener referencia de col. col es AuthName
//Return: std::string amp;
std::string amp; GetCol_AuthName(void)
{
return m_AuthName
}
}
;
//fin de clase CLibrary_rowtype
// //////////////////////////////////////////// ///////// ///
//Contenido: La definición del tipo de clase tbl
//Nombre: CLibrary
class CLibrary {
privado:
CLibrary_rowtype m_EmptyRow;
std: :vectorlt; CLibrary_rowtypegt;
std: :multimaplt; cadena, longgt; m_BookName_idxmmap;
std::multimaplt; std::string, longgt; m_AuthName_idxmmap;
público:
typedef CLibrary_rowtype;
typedef std::vectorlt ;longgt; RPSTYPE; //definición de tipo RPS(conjunto de punteros de retorno)
typedef std::vectorlt;CLibrary_rowtypegt;::iterator TBLITTYPE;
público:
CLibrary()
{
}
virtual ~CLibrary(){;}
público:
//////////////////////////////////////// //////////// ///////////
//Función: Borrar
//Efecto: borrar el tbl.
//Devolución: sin devolución
void Clear(void)
{
m_DATAcorpora.clear();
m_BookName_idxmmap.clear();
> m_AuthName_idxmmap.clear();
}
///////////////////////////// / ///////////////////////////////////Función: GetRowCount
/ /Efecto: obtener el recuento de filas del tbl
//Return: long
long GetRowCount( )
{
return (long )m_DATAcorpora. tamaño();
}
////////////////////////////// // ////////////////////////////////////////Función: GetRowCount
//Efecto: obtiene el recuento de filas del tbl según RPS
//Retorno: long
long GetRowCount(const std::vectorlt; longgt; amp; vRps)
{
return (long)vRps.size();
}
//////// ///// ///////////////////////////////////////////////// // ////
//Función: GetRow
//Efecto: obtener una fila designada
//Retorno: CLibrary_rowtypeamp;
CLibrary_rowtype amp; GetRow(long lRowNum)
{
if(lRowNumgt;=0amp;amp;lRowNumlt;(long)m_DATAcorpora.size())
return m_DATAcorpora[lRowNum];
else
{
CLibrary_rowtype tmpEmptyrow;
m_EmptyRow = tmpEmptyrow;
devolver m_EmptyRow;
}
}
///////////////////// /// /////////////////////////////////////////
/ / Función: GetRow
//Efecto: obtiene una fila designada dentro de RPS
//Retorno: CLibrary_rowtypeamp;
CLibrary_rowtypeamp; longgt; amp; vRps, long lRowNum)
{
long ltmp;
do{
{
Biblioteca
_rowtype tmpEmptyrow;
m_EmptyRow = tmpEmptyrow;
}
ltmp = lRowNum;
if(ltmplt;0) devuelve m_EmptyRow;
if(ltmpgt;=(long)vRps.size()) return m_EmptyRow;
ltmp = vRps[lRowNum];
if(ltmplt;0) return m_EmptyRow;
if(ltmpgt;=(long)m_DATAcorpora.size()) return m_EmptyRow;
return m_DATAcorpora[ltmp];
} while( 0);
}
//////////////////////////////// / ///////////////////////////////Función: Agregar
//Efecto: agregar una fila designada y construye los índices
//Return: no return
void Add(const CLibrary_rowtype amp; varRow)
{
m_DATAcorpora . push_back( varRow);
m_BookName_idxmmap.insert(
std::pairlt; std::string, longgt;(
varRow.m_BookName,
p>(long)(m_DATAcorpora.size()-1) ));
m_AuthName_idxmmap.insert(
std::pairlt; std::string, longgt ; (
varRow.m_AuthName,
(long)(m_DATAcorpora.size()-1) )); / ///////////////////////////////////////////////// ///// /////////////
//Función: SelG_iSuffix
//Efecto: seleccionar y construir RPS donde se usa colgt; atravesar
//Retorno: sin retorno
void SelG_iSuffix(long iVal, std::vectorlt; longgt; amp; vRps) //(n/i)
{
for(long ltmp=0;ltmplt;(long)m_DATAcorpora.size();ltmp)
if(m_DATAcorpora[ltmp].m_iSuffixgt;iVal)
vRps.push_back(ltmp);
}
>
/////////////////////////////////////////////// /// /////////////////
//Función: SelGc_iSuffix
//Efecto: seleccionar y construir RPS donde colgt; val. borrar rps primero.
//Retorno: sin retorno
void SelGc_iSuffix(long iVal, std::vectorlt; longgt; amp; vRps)
{
vRps.clear();
SelG_iSuffix(iVal, vRps)
/////// //// //////////////////////////////////////////////// //////
//Función: SelG_BookName
//Efecto: seleccionar y construir RPS donde colgt; val usa index
//Retorno: sin retorno
void SelG_BookName(std::string strVal, std::vectorlt;longgt;amp;vRps) //(i)
{
para (std::multimaplt;std ::string, longgt; ::iterator it=m_BookName_idxmmap.upper_bound(strVal);
it!=m_BookName_idxmmap.end(); it)
vRps.push_back( it-gt ;segundo );
}
//////////////////////// /////// ////////////////////////////
//Función: SelGc_BookName
//Efecto: seleccione y cree RPS donde colgt; val. borre rps primero.
//Retorno: sin retorno
void SelGc_BookName(std::string strVal, std::vectorlt;longgt; amp ; vRps)
{
vRps.clear()
SelG_BookName(strVal, vRps);
}
//////////////////////////////////////// /////////// ////////
//Función: SelG_AuthName
//Efecto: seleccionar y construir RPS donde colgt; usar índice
// Retorno: sin retorno
void SelG_AuthName(std::string iVal, std::string
vectorlt; longgt; amp; vRps) //(i)
{
for(std::multimaplt; std::string, longgt;::iterator it=m_AuthName_idxmmap.upper_bound (iVal);
it!=m_AuthName_idxmmap.end(); it)
vRps.push_back( it-gt; segundo
}
////////////////////////////////////////////// /// ///////////
//Función: SelGc_AuthName
//Efecto: seleccione y cree RPS donde colgt borre rps primero.
//Retorno: sin retorno
void SelGc_AuthName(std::string iVal, std::vectorlt; longgt; amp; vRps)
{
vRps.clear();
SelG_AuthName(iVal, vRps);
}
////////// // ///////////////////////////////////////////////// /
//Función: SelE_iSuffix
//Efecto: seleccionar y construir RPS donde col=val usa atravesar
//Retorno: sin retorno
void SelE_iSuffix(long iVal, std:: vectorlt; longgt; amp; vRps) //(n/i)
{
for(long ltmp=0; ltmplt; (largo) m_DATAcorpora.size(); ltmp )
if(m_DATAcorpora[ltmp].m_iSuffix==iVal)
vRps.push_back( ltmp);
}
//////////////////////////////////////// //////// ////////////
//Función: SelE1_iSuffix
//Efecto: seleccione la primera fila donde col=val o devolver la fila predeterminada.
//Return: CLibrary_rowtypeamp;
CLibrary_rowtypeamp; SelE1_iSuffix(long iVal)
{
std: :vectorlt; vRps;
SelE_iSuffix( iVal, vRps
devuelve GetRow( vRps, 0 ); >/////
////////////////////////////////////////////////// //// /
//Función: SelEc_iSuffix
//Efecto: seleccione y cree RPS donde col=val borre rps primero.
// Retorno: sin retorno
void SelEc_iSuffix(long iVal, std::vectorlt; longgt; amp; vRps)
{
vRps.clear();
SelE_iSuffix(iVal, vRps);
}
////////////////////// ///// ////////////////////////////////////////////// //Función: SelNE_iSuffix
//Efecto: seleccionar y crear RPS donde col!=val
//Retorno: sin retorno
void SelNE_iSuffix(long iVal , std:: vectorlt; amp; vRps)
{
SelL_iSuffix(iVal, vRps); p>
}
////////////////////////////////////// ////// ///////////////////
//Función: SelNEc_iSuffix
//Efecto: seleccionar y construya RPS donde col!=val . borre rps primero.
//Retorno: sin retorno
void SelNEc_iSuffix(long iVal, std::vectorlt; longgt; amp; vRps)
{
vRps.clear();
SelNE_iSuffix(iVal, vRps
}
/ /////// //////////////////////////////////////////// //////// p>
//Función: SelE_BookName
//Efecto: seleccionar y construir RPS donde col=val usa índice
//Retorno: sin retorno
void SelE_BookName(std::string strVal, std::vectorlt;longgt;amp;vRps) //(i)
{
std ::pairlt; std::multimaplt ;std::string, longgt;::iterador, std::multimaplt; std::string, longgt;::iteratorgt;
pa = m_BookName_idxmmap.equal_range(strVal);
for(std::multimaplt; std::string, longgt;::iterator it=pa.first; it!=pa.segundo; it )
vRps.push_back( it-gt; segundo );
}
//////////////// ///////////////////////////////////////////////Función: SelE1_BookName
//Efecto: seleccione la primera fila donde col=val, o devuelva la fila predeterminada.
//Retorno: CLibrary_rowtypeamp;
CLibrary_rowtypeamp; SelE1_BookName( std:: cadena strVal)
{
std:: vectorlt; vRps;
SelE_BookName( strVal, vRps > return GetRow); (vRps, 0);
}
/////////////////////////// // ////////////////////////////
//Función: SelEc_BookName
// Efecto : seleccione y cree RPS donde col=val. borre rps primero.
//Retorno: sin retorno
void SelEc_BookName(std::string strVal, std::vectorlt; longgt; amplificador; vRps)
{
vRps.clear();
SelE_BookName(strVal, vRps); >
/////////////////////////////////////////////// // ///////////////
//Función: SelNE_BookName
//Efecto: seleccionar y construir RPS donde col!=val
//Retorno: sin retorno
void SelNE_BookName(std::string strVal, std::vectorlt;longgt;amp;vRps)
{
SelL_BookName(strVal, vRps);
SelG_BookName(strVal, vRps);
}
////////// // ///////////////////////////////////////////////// //
//Función: SelNEc_BookName
//Efecto: se
seleccione y cree RPS donde col!=val. borre rps primero.
//Return: no return
void SelNEc_BookName(std::string strVal, std::vectorlt;longgt; amplificador; vRps)
{
vRps.clear();
SelNE_BookName(strVal, vRps); >
/////////////////////////////////////////////// /// ////////////////
//Función: SelE_AuthName
//Efecto: seleccionar y construir RPS donde col=val usar índice
//Retorno: sin retorno
void SelE_AuthName(std::string iVal, std::vectorlt;longgt;amp;vRps) //(i)
{
std::pairlt; std::multimaplt; std::string, longgt;::iterator, std::multimaplt; ;
pa = m_AuthName_idxmmap.equal_range(iVal);
for(std::multimaplt; std::string,longgt;::iterator it=pa.first; it!= pa.segundo; it)
vRps.push_back( it-gt; segundo );
}
/////////// /// //////////////////////////////////////////////// //
//Función: SelE1_AuthName
//Efecto: selecciona la primera fila donde col=val, o devuelve la fila predeterminada.
//Retorno: CLibrary_rowtypeamp ;
CLibrary_rowtype & SelE1_AuthName(std::string iVal)
{
std::vectorlt;longgt;
SelE_AuthName (iVal, vRps) ;
return GetRow(vRps, 0);
}
////////////// //// /////////////////////////////////////////////
/ /Función: SelEc_AuthName
//Efecto: seleccione y cree RPS donde col=val borre rps primero.
/
/Retorno: sin retorno
void SelEc_AuthName(std::string iVal, std::vectorlt;longgt;amp;vRps)
{
vRps.clear ();
SelE_AuthName(iVal, vRps);
}
/////////////////// ///////////////////////////////////////////////Función: SelNE_AuthName
//Efecto: seleccione y cree RPS donde col!=val
//Retorno: sin retorno
void SelNE_AuthName(std::string iVal, std :: vectorlt; amp; vRps)
{
SelL_AuthName(iVal,vRps);
SelG_AuthName(iVal,vRps);
}
//////////////////////////////////////// // //////////////////////////////Función: SelNEc_AuthName
//Efecto: seleccionar y construir RPS donde col!=val. borrar rps primero.
//Retorno: sin retorno
void SelNEc_AuthName(std::string iVal, std::vectorlt; longgt; amp; vRps)
{
vRps.clear();
SelNE_AuthName(iVal, vRps)
}
////////////////////////////////////////////////// //// /////////
//Función: SelL_iSuffix
//Efecto: seleccionar y construir RPS donde collt; val use traverse
/ /Retorno: sin retorno
void SelL_iSuffix(long iVal, std::vectorlt; longgt; amp; vRps) //(n/i)
{
for(long ltmp=0;ltmplt;(long)m_DATAcorpora.size();ltmp )
if(m_DATAcorpora[ltmp].m_iSuffixlt;iVal)
vRps.push_back( ltmp);
}
///////////////////////////// ///// ///////////////////////////
//Función: SelLc_iSuffix
/
/Efecto: seleccione y cree RPS donde collt; val. borre rps primero.
//Retorno: sin retorno
void SelLc_iSuffix(long iVal, std::vectorlt; longgt; amp ; vRps)
{
vRps.clear()
SelL_iSuffix(iVal, vRps)
//////////////////////////////////////////////// /// ////////
//Función: SelL_BookName
//Efecto: seleccionar y construir RPS donde collt; val usa index
// Retorno: sin retorno
void SelL_BookName(std::string strVal, std::vectorlt;longgt; amp; vRps) //(i)
{
std::pairlt; std::multimaplt; std::string,longgt;::iterador, std::multimaplt; std::string,longgt;::iteratorgt;pa;
pa = m_BookName_idxmmap .equal_range(strVal);
for(std::multimaplt; std::string, longgt;::iterator it=m_BookName_idxmmap.begin(); it!=pa.first; it)
vRps.push_back( it-gt; segundo
}
///////////////// // ///////////////////////////////////////////
// Función: SelLc_BookName
//Efecto: seleccionar y construir RPS donde collt; borrar rps primero.
//Retorno: sin retorno
void SelLc_BookName( std::string strVal, std::vectorlt;longgt;amp;vRps)
{
vRps.clear();
SelL_BookName( strVal, vRps );
}
/////////////////////////////// ///// ///////////////////////////////////Función: SelL_AuthName
//Efecto: seleccione y cree RPS donde collt; val use index
//Retorno: sin retorno
void S
elL_AuthName(std::string iVal, std::vectorlt;longgt;amp;vRps) //(i)
{
std::pairlt; std::multimaplt; ::string, longgt; ::iterator, std::multimaplt; std::string, longgt; ::iteratorgt;
pa = m_AuthName_idxmmap.equal_range(iVal);
for(std::multimaplt; std::string, longgt;::iterator it=m_AuthName_idxmmap.begin(); it!=pa.first; it)
vRps.push_back( it-gt; segundo );
}
//////////////////////////////// // //////////////////////////////////////Función: SelLc_AuthName
//Efecto: seleccione y cree RPS donde collt; val. borre rps primero.
//Retorno: sin retorno
void SelLc_AuthName(std::string iVal, std::vectorlt ; largogt; vRps)
{
vRps.clear();
SelL_AuthName(iVal, vRps);
//////////////////////////////////////////// // /////////////////
//Función: RpsAnd
//Efecto: establece la intersección para RPSs varRpsSource1. también el resultado.
//Return: RPSTYPE amp;
RPSTYPE amp RpsAnd(RPSTYPE amp; varRpsSource1, RPSTYPE amp; varRpsSource2)
{
std::sort(varRpsSource1.begin(), varRpsSource1.end());
std::sort( varRpsSource2.begin(), varRpsSource2.end());
RPSTYPE source3(varRpsSource1.size() varRpsSource2.size());
RPSTYPE::iterator itNewEnd2 = std::set_intersection(
varRpsSource1.begin() , varRpsSource1 .end(), varRpsSource2.begin(), varRpsSo
urce2.end(), source3.begin() );
varRpsSource1.clear()
for(RPSTYPE::iterator it=source3.begin(); it!= itNewEnd2; it) varRpsSource1.push_back(*it);
return varRpsSource1;
}
///////////// /////////////////////////////////////////////////
//Función: RpsOr
//Efecto: establecer unión para RPS, varRpsSource1 también es el resultado.
//Retorno: RPSTYPE amp;
RPSTYPE y RpsOr( RPSTYPE y varRpsSource1, RPSTYPE y varRpsSource2 )
{
std::sort( varRpsSource1.begin(), varRpsSource1.end() ); /p>
std::sort(varRpsSource2.begin(), varRpsSource2.end());
RPSTYPE source3(varRpsSource1.size() varRpsSource2.size());
RPSTYPE::iterator itNewEnd2 = std::set_union(
varRpsSource1.begin(), varRpsSource1.end(), varRpsSource2.begin(), varRpsSource2.end(), source3.begin()
varRpsSource1.clear();
for(RPSTYPE::iterator it=source3.begin(); it!=itNewEnd2; it) varRpsSource1.push_back(*it) ;
return varRpsSource1;
}
}
//fin de la clase CLibrary