那个Set容器的问题，源代码在这里

最新推荐文章于 2019-01-25 15:47:45 发布
最新推荐文章于 2019-01-25 15:47:45 发布
阅读量1.1k 收藏
点赞数
文章标签： iterator insert class null float each
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AlfredLu/article/details/1769202
版权

// 调用函数
int CTriNetInterp::CreateTriNet(float **pfPole, int **pnPoleIndex, int nIndexNum, int *pnPoleNum, triangleMSet &triNet)
{
 vertexSet vertexNew;
 triangleMSet triNetNew;
 triangleIterator tItDump;
 vertexIterator vItDump;

 triNet.clear();
 
 if (pfPole == NULL || pnPoleIndex == NULL || pnPoleNum == NULL)
  return -1;

 for (i=0; i<nIndexNum; i++)
 {
  vertexNew.clear();
  triNetNew.clear();

  // insert data into vertex new
  for (j=0; j<pnPoleNum[i]; j++)
   vertexNew.insert(CVertex(pfPole[pnPoleIndex[i][j]][0], pfPole[pnPoleIndex[i][j]][1], pfPole[pnPoleIndex[i][j]][2]));
 
  // dump vertex new，打印的对的
  TRACE("/tNew Vertex get %d elements!/n", vertexNew.size());
  TRACE("++/n/tDump vertex set begin/n");
  for (vItDump=vertexNew.begin(); vItDump!=vertexNew.end(); vItDump++)
  {
   TRACE("/t/tvertex new :/t(%f, %f, %f)/n",
     vItDump->GetX(), vItDump->GetY(), vItDump->GetZ());
  }
  TRACE("/tDump end/n--/n");  

  // CALL THIS FUNCTION HERE!!
  GrowthTriangulation(vertexNew, triNetNew);

  if (triNetNew.empty())
   return -1;

  // walk through triNetNew, dump each value elements, some dumps content is not correct
  for (tItDump = triNetNew.begin(); tItDump != triNetNew.end(); tItDump++)
  {
   TRACE("/t/tTriangle Insert:/t(%f, %f, %f) /t-/t (%f, %f, %f) /t-/t (%f, %f, %f)/n",
    tItDump->GetVertex(0)->GetX(), tItDump->GetVertex(0)->GetY, tItDump->GetVertex(0)->GetZ(),
    tItDump->GetVertex(1)->GetX(), tItDump->GetVertex(1)->GetY, tItDump->GetVertex(1)->GetZ(),
    tItDump->GetVertex(2)->GetX(), tItDump->GetVertex(2)->GetY, tItDump->GetVertex(2)->GetZ());

   // insert each elements into triNet
   triNet.insert(CTriangle(tItDump->GetVertex(0), tItDump->GetVertex(1), tItDump->GetVertex(2)));
  }
 }
 
 return 0;
}

// 被调函数
void CTriNetInterp::GrowthTriangulation(vertexSet &vertex, triangleMSet & TriNet)
{
 TRACE("CTriNetInterp::GrowthTriangulation/n");

 edgeSet workESet;
 vertexIterator vIt, vItDump;

 CVertex vertexFirst[3];
 CreateFirstTri(vertex, vertexFirst);

 workESet.insert(CEdge(&vertexFirst[0], &vertexFirst[1])); // base edge I (begin -> third)
 workESet.insert(CEdge(&vertexFirst[1], &vertexFirst[2]));   // base edge II (third -> closest)

 // insert one element here
 TriNet.insert(CTriangle(&vertexFirst[0], &vertexFirst[1], &vertexFirst[2]));
 edgeIterator eIt = workESet.begin(), eItDump;
 
 triangleIterator tItDump;
 
 // Go growth
 TRACE("++/n/tBegin growth/n");
 while (eIt != workESet.end())
 {
  double disMin = 1E20F;
  vertexIterator vItClosest = vertex.begin();
  
  //
  // find the closest vertex to the base edge, and this vertex is not in
  // any existed triangle's circumcircle, we stop searching when no more
  // match vertex
  //
  ......
   
  TRACE("/t/tFind a closest vertex(%f, %f, %f) to current edge/n", vItClosest->GetX(), vItClosest->GetY(), vItClosest->GetZ());
  workESet.insert(CEdge(eIt->m_pV0, &(*vItClosest)));
  workESet.insert(CEdge(&(*vItClosest), eIt->m_pV1));
  
  // insert new triangle here，找到了满足条件的顶点，就生成一个新的三角形
  TriNet.insert(CTriangle(eIt->m_pV0, &(*vItClosest), eIt->m_pV1));


  // dump triangle, all dump content is correct
  TRACE("/t/t++/n/t/t/tDump trinet begin/n");
  for (tItDump = TriNet.begin(); tItDump!=TriNet.end(); tItDump++)
  {
   TRACE("/t/t/t/tTriangle :/t(%f, %f, %f) /t-/t (%f, %f, %f) /t-/t (%f, %f, %f)/n",
     tItDump->GetVertex(0)->GetX(), tItDump->GetVertex(0)->GetY(), tItDump->GetVertex(0)->GetZ(),
     tItDump->GetVertex(1)->GetX(), tItDump->GetVertex(1)->GetY(), tItDump->GetVertex(1)->GetZ(),
     tItDump->GetVertex(2)->GetX(), tItDump->GetVertex(2)->GetY(), tItDump->GetVertex(2)->GetZ());
  }
  TRACE("/t/t/tDump end/n/t/t--/n");

  eIt++;
 }
 TRACE("/tEnd growth/n--/n");
}

// 下面是一些类的定义
//
// CTriangle
class CTriangle
{
public:
 void SetCircumCircle();
 CTriangle(const CTriangle& tri)
  :m_Center(tri.m_Center)
  ,m_R(tri.m_R)
 {
  for (int i=0; i<3; i++)
   m_pVertex[i] = tri.m_pVertex[i];
 }
 
 CTriangle(const CVertex *pV0, const CVertex *pV1, const CVertex *pV2)
 {
  m_pVertex[0] = pV0;
  m_pVertex[1] = pV1;
  m_pVertex[2] = pV2;

  SetCircumCircle();
 }

 CTriangle(const CVertex *pV)
 {
  for (int i=0; i<3; i++)
   m_pVertex[i] = pV++;
  SetCircumCircle();
 }

 const CVertex* GetVertex(int i) const
 {
  ASSERT(i >=0 && i<3);
  return m_pVertex[i];
 }

 BOOL operator< (const CTriangle& tri) const
 {
  return m_Center < tri.m_Center;
 }
 
 BOOL operator== (const CTriangle& tri) const
 {
  return !(m_Center == tri.m_Center);
 }

 //
 // Return true if vIt is in the triangle's circumcircle
 // Return false if vIt is out or on the circle
 //
 BOOL bVertexInCircumcircle(CVertex v) const
 {
  CVertex vetexCenter(m_Center);
  CEdge deltaVector(&vetexCenter, &v);
  return deltaVector.GetLength() < sqrt(pow(m_R,2));
 }
protected:
 CPointF m_Center; // center of circumcircle
 double m_R;   // redius of circumcircle
 const CVertex *m_pVertex[3];  // counterclockwise
};

//
// CPoint
class CPointF
{
public:
 CPointF() {X=0.0; Y=0.0; Z=0.0;}
 CPointF(const CPointF& p) {X=p.X; Y=p.Y; Z=p.Z;}
 CPointF(double dx, double dy, double dz){X=dx;Y=dy;Z=dz;}
 CPointF operator+(const CPointF& p) const
 {
  return CPointF(X+p.X, Y+p.Y, Z+p.Z);
 }
 CPointF operator-(const CPointF& p) const
 {
  return CPointF(X-p.X, Y-p.Y, Z-p.Z);
 }

 //
 // the order of x,y,z is very important, as follow define, the bigger
 // one is in the top-right-front direction of smaller one
 //
 BOOL operator<(const CPointF& p) const
 {
  if (X == p.X && Y == p.Y)
   return Z < p.Z;
  else if (X == p.X)
   return Y < p.Y;
  else
   return X < p.X;
 }

 BOOL operator==(const CPointF& p) const
 {
  return X==p.X && Y==p.Y && Z==p.Z;
 }

 double X;
 double Y;
 double Z;
}; 

//
// CVertex
class CVertex
{
public:
 CVertex():m_point(0.0, 0.0, 0.0),m_bBeAssigned(FALSE) {}
 CVertex(const CVertex& v):m_point(v.m_point),m_bBeAssigned(FALSE) {}
 CVertex(const CPointF& p):m_point(p),m_bBeAssigned(FALSE) {}
 CVertex(double dx, double dy, double dz):m_point(dx,dy,dz),m_bBeAssigned(FALSE) {}
 CVertex(int nx, int ny, int nz):m_point((double)nx, (double)ny, (double)nz),m_bBeAssigned(FALSE){}

 BOOL operator<(const CVertex &v) const
 {
  return m_point < v.m_point;
 }

 // Effect STL code 21
 BOOL operator==(const CVertex &v) const
 {
  return !(m_point == v.m_point);
 }

 BOOL IsAssigned() const {return m_bBeAssigned;}

 void MarkAssigned() {m_bBeAssigned = TRUE;}

 double GetX() const {return m_point.X;}
 double GetY() const {return m_point.Y;}
 double GetZ() const {return m_point.Z;}
 void SetX(double dx) {m_point.X = dx;}
 void SetY(double dy) {m_point.Y = dy;}
 void SetZ(double dz) {m_point.Z = dz;}
 const CPointF& GetPoint() const {return m_point;}

protected:
 CPointF m_point;
 BOOL m_bBeAssigned;
};


//
// CEdge, m_pV0 -> m_pV1
class CEdge
{
public:
 CEdge(const CEdge& e): m_pV0(e.m_pV0), m_pV1(e.m_pV1) {}
 CEdge(const CVertex *pV0, const CVertex *pV1): m_pV0(pV0), m_pV1(pV1) {}
 
 //
 // large one is on the top-right-front direction of small one
 //
 BOOL operator<(const CEdge& e) const
 {
  if (m_pV0 == e.m_pV0)
   return *m_pV1 < *e.m_pV1;
  return *m_pV0 < *e.m_pV0;
 }

 // Effect STL code 21
 BOOL operator==(const CEdge& e) const
 {
  return !(m_pV0->GetPoint() == e.m_pV0->GetPoint() && m_pV1->GetPoint() == e.m_pV1->GetPoint());
 }

 ......
 const CVertex *m_pV0;
 const CVertex *m_pV1;
};

//
// CTriNetInterp
class CTriNetInterp 
{
public:
 int CreateTriNet(float **pfPole, int **pnPoleIndex, int nIndexNum, int *pnPoleNum, triangleMSet &triNet);
 void GrowthTriangulation(vertexSet &vertex, triangleMSet &TriNet);
 CTriNetInterp(){}
 virtual ~CTriNetInterp(){}
};

typedef set<CVertex> vertexSet;
typedef set<CVertex>::iterator vertexIterator;
typedef set<CVertex>::const_iterator cvertexIterator;

typedef set<CEdge> edgeSet;
typedef set<CEdge>::iterator edgeIterator;
typedef set<CEdge>::const_iterator cedgeIterator;

typedef multiset<CTriangle> triangleMSet;
typedef multiset<CTriangle>::iterator triangleIterator;
typedef multiset<CTriangle>::const_iterator ctriangleIterator;

// 下面是打印的内容

// 在被调用函数里面的最后一次dump内容， 是对的

00001823 13:49:04.572 [800]   ++  
00001824 13:49:04.572 [800]    Dump trinet begin  
00001825 13:49:04.572 [800]     Triangle : (-39.000000, -0.500000, 8.500000)  -  (-39.200001, -1.000000, 15.000000)  -  (-39.000000, 0.000000, 3.000000)  
00001826 13:49:04.572 [800]     Triangle : (-39.500000, -4.300000, 8.000000)  -  (-40.000000, -5.000000, 13.800000)  -  (-39.500000, -4.300000, 2.500000)  
00001827 13:49:04.572 [800]     Triangle : (-37.000000, -10.500000, 15.000000)  -  (-37.500000, 2.000000, 17.000000)  -  (-40.000000, -8.000000, 7.300000)  
00001828 13:49:04.572 [800]     Triangle : (-41.000000, -9.200000, 11.600000)  -  (-39.500000, -4.300000, 2.500000)  -  (-40.000000, -8.000000, 7.300000)  
00001829 13:49:04.572 [800]     Triangle : (-41.000000, -9.200000, 11.600000)  -  (-39.000000, 0.000000, 3.000000)  -  (-39.500000, -4.300000, 8.000000)  
00001830 13:49:04.572 [800]     Triangle : (-41.000000, -9.200000, 11.600000)  -  (-39.000000, -0.500000, 8.500000)  -  (-39.000000, 0.000000, 3.000000)  
00001831 13:49:04.572 [800]     Triangle : (-39.000000, 0.000000, 3.000000)  -  (-37.500000, 5.000000, 4.500000)  -  (-39.500000, -4.300000, 8.000000)  
00001832 13:49:04.572 [800]     Triangle : (-41.000000, -9.200000, 11.600000)  -  (-39.500000, -4.300000, 8.000000)  -  (-39.500000, -4.300000, 2.500000)  
00001833 13:49:04.572 [800]     Triangle : (-39.500000, -4.300000, 2.500000)  -  (-36.000000, -8.000000, 17.000000)  -  (-37.000000, -10.500000, 15.000000)  
00001834 13:49:04.572 [800]     Triangle : (-39.500000, -4.300000, 2.500000)  -  (-35.000000, -5.000000, 18.000000)  -  (-36.000000, -8.000000, 17.000000)  
00001835 13:49:04.572 [800]     Triangle : (-39.500000, -4.300000, 2.500000)  -  (-34.000000, -3.000000, 19.000000)  -  (-35.000000, -5.000000, 18.000000)  
00001836 13:49:04.572 [800]     Triangle : (-37.500000, 5.000000, 4.500000)  -  (-32.000000, 8.400000, 13.000000)  -  (-39.500000, -4.300000, 8.000000)  
00001837 13:49:04.572 [800]     Triangle : (-39.500000, -4.300000, 2.500000)  -  (-33.000000, -1.000000, 20.000000)  -  (-34.000000, -3.000000, 19.000000)  
00001838 13:49:04.572 [800]     Triangle : (-37.500000, 3.500000, 10.500000)  -  (-35.000000, 6.500000, 12.300000)  -  (-32.000000, 11.100000, 7.500000)  
00001839 13:49:04.572 [800]     Triangle : (-39.000000, 0.000000, 3.000000)  -  (-37.500000, 3.500000, 10.500000)  -  (-32.000000, 11.100000, 7.500000)  
00001840 13:49:04.572 [800]     Triangle : (-37.500000, 5.000000, 4.500000)  -  (-26.000000, 7.300000, 18.500000)  -  (-28.500000, 9.700000, 13.300000)  
00001841 13:49:04.572 [800]     Triangle : (-39.500000, -4.300000, 2.500000)  -  (-23.000000, 7.600000, 19.000000)  -  (-20.000000, 2.500000, 22.000000)  
00001842 13:49:04.572 [800]     Triangle : (-39.500000, -4.300000, 2.500000)  -  (-31.000000, 0.600000, 21.000000)  -  (-33.000000, -1.000000, 20.000000)  
00001843 13:49:04.572 [800]     Triangle : (-39.500000, -4.300000, 2.500000)  -  (-37.000000, -10.500000, 15.000000)  -  (-40.000000, -8.000000, 7.300000)  
00001844 13:49:04.572 [800]     Triangle : (-37.000000, -10.500000, 15.000000)  -  (-35.000000, 4.000000, 17.799999)  -  (-37.500000, 2.000000, 17.000000)  
00001845 13:49:04.572 [800]     Triangle : (-37.500000, 5.000000, 4.500000)  -  (-28.500000, 9.700000, 13.300000)  -  (-32.000000, 8.400000, 13.000000)  
00001846 13:49:04.572 [800]     Triangle : (-39.000000, 0.000000, 3.000000)  -  (-35.000000, 8.000000, 6.000000)  -  (-37.500000, 5.000000, 4.500000)  
00001847 13:49:04.572 [800]     Triangle : (-37.500000, 5.000000, 4.500000)  -  (-29.000000, 6.500000, 18.299999)  -  (-26.000000, 7.300000, 18.500000)  
00001848 13:49:04.572 [800]     Triangle : (-37.000000, -10.500000, 15.000000)  -  (-32.000000, 5.600000, 18.000000)  -  (-35.000000, 4.000000, 17.799999)  
00001849 13:49:04.572 [800]     Triangle : (-39.500000, -4.300000, 2.500000)  -  (-26.000000, 1.900000, 22.000000)  -  (-29.000000, 1.400000, 22.000000)  
00001850 13:49:04.572 [800]     Triangle : (-37.000000, -10.500000, 15.000000)  -  (-20.000000, 7.800000, 19.000000)  -  (-32.000000, 5.600000, 18.000000)  
00001851 13:49:04.572 [800]     Triangle : (-39.500000, -4.300000, 2.500000)  -  (-29.000000, 1.400000, 22.000000)  -  (-31.000000, 0.600000, 21.000000)  
00001852 13:49:04.572 [800]     Triangle : (-39.500000, -4.300000, 2.500000)  -  (-23.000000, 2.300000, 22.000000)  -  (-26.000000, 1.900000, 22.000000)  
00001853 13:49:04.572 [800]     Triangle : (-39.500000, -4.300000, 2.500000)  -  (-20.000000, 2.500000, 22.000000)  -  (-23.000000, 2.300000, 22.000000)  
00001854 13:49:04.572 [800]     Triangle : (-39.000000, 0.000000, 3.000000)  -  (-32.000000, 11.100000, 7.500000)  -  (-35.000000, 8.000000, 6.000000)  
00001855 13:49:04.572 [800]    Dump end  
00001856 13:49:04.572 [800]   --  
00001857 13:49:04.572 [800]   Find no more closet vertex  
00001858 13:49:04.572 [800]  End growth  
00001859 13:49:04.572 [800] --  

 // 在调用函数里面dump的内容，完全是错的

00001860 13:49:04.572 [800]   Triangle Insert: (-39.000000, 0.000000, -0.000000)  -  (0.000000, 15.000000, -39.000000)  -  (0.000000, -41536555050348815000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000000, 0.000000)  
00001861 13:49:04.587 [800]   Triangle Insert: (-39.500000, 0.000000, 0.000000)  -  (0.000000, 13.800000, 0.000000)  -  (0.000000, -41536549821854824000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000000, 0.000000)  

AlfredLu
关注
C++(STL):27 ---关联式容器set源码剖析
网易搬砖选手
12-19 273
一、setset语法使用参阅：set的特性set所有元素都会根据元素的键值自动被排序set中的键值就是实值，实值就是键值默认情况下set不允许两个元素重复set的迭代器不能根据set的迭...
set容器的讲解（STL）（c++代码实现）
m0_53175693的博客
10-24 328
set容器很特殊，不允许重复插入，其底层为二叉树，且有自动排序的功能： #include<iostream> using namespace std; #include<set> void print(set<int>&s) { for (set<int>::iterator it = s.begin(); it != s.end(); it++) { cout << *it << " "; } cout <&
C++ set容器（附代码）
zamaochick的博客
08-31 733
set内部其实是一颗二叉搜索树。其基本函数如下： size（）：返回set的集合数。 clear（）：清空set。 O（n） begin（）：返回指向set开头的迭代器。 end（）：返回指向set末尾的迭代器。  insert（key）：向set中插入元素key。O（log（n））   erase（key）：删除含有key的元素。 O（log（n）） find（key）： 查找与k...
C++基础——STL——set
gengsj
01-25 248
set 翻译为 集合，是一个 内部自动有序 且 不含重复元素 的容器。 1. 定义 set&lt;typaname&gt; name; // 示例 set&lt;int&gt; name; set&lt;double&gt; name; set&lt;char&gt; name; set&lt;node&gt; name; // node 为结构体类型 // set 数组的定义 set&l...
最小生成树--prime
dianduo0824的博客
12-27 359
/*邻接矩阵存储-Prim最小生成树算法*/ VertexFindMinDist(MGraphGraph,WeightTypedist[]) {/*返回未被收录顶点中dist最小者*/ VertexMinV,V; WeightTypeMinDist=INFINITY; for(V=0;V&...
STL — set容器的使用详解
阿亮的博客
11-06 3162
set容器的使用详解 其实map和set是天生一对
SpringMVC 源代码深度解析 IOC容器（Bean 解析、注册）
在前进的路上
10-31 6262
SpringMVC通过一个配置文件描述Bean以及Bean之间的依赖关系，利用java的反射机制实例化Bean并建立Bean之间的依赖关系。IOC容器在完成这些底层工作的基础还提供了Bean的实例缓、生命周期、Bean实例代理等。BeanFacory是SpringMVC框架最核心的接口，他提供了最高级IOC的配置机制。ApplicationContext由BeanFactory派生而来，这也说明了 SpringMVC容器中运行的主体对象是 Bean，另外 ApplicationContext 继承了 Res
doom3 源代码评测 1
tailiangliang的专栏
05-11 4096
原文地址 http://fabiensanglard.net/doom3/ 2012年6月8日 DOOM3源代码评测：简介（第1部分，共6部分）>> 2011年11月23日，id软件保持传统，并发布了其以前引擎的源代码。这一次是轮到了idTech4，使用它，创造出Prey,quake4，当然是Doom 3.在几个小时之内，GitHub上的源代码被下载了400多次，
C++set介绍及详细使用示例（源代码）
05-25
3. **快速查找**：由于 `set` 的内部结构为红黑树，因此对于查找、插入和删除等操作，时间复杂度均为 O(log n)，这里的 n 表示容器中元素的数量。 4. **不支持直接修改元素**：由于 `set` 的元素是通过值来存储的，...
《C++数据结构原理与经典问题求解》的配套源代码
11-01
总之，《C++数据结构原理与经典问题求解》的配套源代码是学习C++数据结构和算法的宝贵资源，通过实际操作和调试，读者能够更加牢固地掌握这些知识，并能将其应用于实际项目中，提升自己的编程能力。
Essential C++源代码
04-28
8. **STL（标准模板库）**：STL包含一系列容器（如vector、list、set等）、迭代器、算法和函数对象，是C++编程中不可或缺的一部分。 9. **命名空间**：命名空间用于避免命名冲突，使代码更易于管理和组织。 10. **...
CSet源代码，集合类的C++源代码
01-21
在C++编程语言中，集合类（通常称为Set）...通过分析`CSet`的源代码，我们可以学习到自定义数据结构的设计技巧，以及如何在C++中高效地实现集合类。同时，这也可以作为一个案例，帮助理解STL中的`std::set`的工作原理。
【STL源代码】C++标准库STL源代码下载
09-05
在【STL源代码】中，我们可以深入学习并理解这些组件的实现细节，从而提高编程技能和效率。 1. 容器： - `vector`：动态数组，提供了类似数组的功能，可以在任何位置进行插入和删除元素，自动管理内存。 - `list`...
rhino grasshoper 框内物体排列（附视频）.gh
最新发布
10-18
【闭合线内物体按方向移动/排列】https://www.bilibili.com/video/BV1z1WfeSEWu?vd_source=b420114c993138474d2e93d83ead77a5
kwant-1.4.3-cp38-cp38-win_amd64.whl
10-18
kwant-1.4.3-cp38-cp38-win_amd64.whl
rhino grasshoper 景观椅（附视频）.gh
10-18
【rhino@grasshoper 曲线金属座椅景观案例（文件获取/见简介）】https://www.bilibili.com/video/BV1Dx4y147Lr?vd_source=b420114c993138474d2e93d83ead77a5
PCIe通义万问系列文档的第一部已整理完毕，含999个PCIe相关问答
10-18
《PCIe通义万问》系列文档旨在记录PCIe相关行业工程师们在PCIe协议学习、IP设计验证、产品测试及使用过程中遇到的问题、迸发的思考、进行的探讨及可能的解决方案，以期给遇到相同相似问题的同行们些许启发。文档涉及的技术方向主要为PCIe，也包含PCIe相关的CXL、UCIe及计算机体系结构相关内容。 本文档是《PCIe通义万问》系列文档之（一），含999个问题。问题内容有以下三个来源：MangoPapa（下称博主）的“PCIe每日一问一答”系列专栏；博主的博文留言及私信讨论；博主作为群主的“PCIe技术交流群”群聊内容。MangoPapa小助理、折叠、先杰、CR小队长、kangling共同完成了问答内容提取与归纳整理，噫嘘唏及慕荷负责文辞优化及编辑排版，上述人员及MangoPapa、JasonW、皮塞阿姨、席可儿参与了文档内容的审校。感谢以上人员的无私奉献。 本文档仅对讨论内容进行总结记录，不保证问题答案的正确性，部分问题只提供解决思路或讨论过程。术业有专攻，文内定有偏颇。如您发现谬误，一敬希原宥，二望乞点拨；如您持异见，欢迎来信讨论。如有需要，欢迎联系MangoPapa加入相关
毕业设计论文SpringBoot招投标管理系统.docx
10-18
毕业设计论文
直观的大型模型应用软件-有机体-eva.zip
10-18
直观的大型模型应用软件-有机体-eva
探索JavaEE中的JSTL源代码应用
在Java EE源代码中，开发者可以找到JSTL的具体实现细节，比如标签的处理流程、如何与Java EE容器交互等。这有助于开发者深入理解JSTL的工作原理，并在需要时对其进行定制或优化。此外，源代码还可以作为学习材料，供...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值