1>e:\tempc++\test10\test10\vector.h(20): error C2440: “default argument”: 无法从“int”转换为“Vertex<Tv>”

1>e:\tempc++\test10\test10\vector.h(20): error C2440: “default argument”: 无法从“int”转换为“Vertex”,这是为什么？定义向量的时候是用Vertex代替模板T，怎么就无法从“int”转换为“Vertex”？
main

#include<iostream>
using namespace std;
#include"GraphMatrix.h"

int main()
{
    string vertex;
    GraphMatrix<string,int> graph;
    int choice=0;
    cout<<"添加节点请输入1，添加边请输入2，删除节点请输入3，删除边请输入4，显示图请输入5。"<<endl;
    cin>>choice;
    /*switch(choice)
    {
    case 1:

    }*/
    return 0;
}

Graph.h

#ifndef _GRAPH__H_
#define _GRAPH__H_
#include<limits.h>
typedef enum{UNDISCOVERED,DISCOVERED,VISITED} VStatus;
typedef enum{UNDETERMINED,TREE,CROSS,FORWARD,BACKWARD} EType;

template<typename Tv,typename Te>
class Graph{
private:
    void reset(){
        for(int i=0;i<n;i++){
            status(i)=UNDISCOVERED;
            dTime(i)=fTime(i)=-1;
            parent(i)=-1;
            priority(i)=INT_MAX;
            for(int j=0;j<n;j++)//所有边的
                if(exists(i,j))
                    type(i,j)=UNDETERMINED;//类型
        }
    }
    void BFS(int,int&);//广度优先
public:
    //顶点
    int n;
    virtual int insert(Tv const&)=0;
    virtual Tv remove(int)=0;
    virtual Tv& vertex(int)=0;//顶点v数据
    virtual int inDegree(int)=0;
    virtual int outDegree(int)=0;
    virtual int firstNbr(int)=0;
    virtual int nextNbr(int,int)=0;
    virtual VStatus& status(int)=0;
    virtual int& dTime(int)=0;
    virtual int& fTime(int)=0;
    virtual int& parent(int)=0;
    virtual int& priority(int)=0;
    //边
    int e;
    virtual bool exists(int,int)=0;
    virtual void insert(Te const&,int,int,int)=0;
    virtual Te remove(int,int)=0;
    virtual EType& type(int,int)=0;
    virtual Te& edge(int,int)=0;
    virtual int& weight(int,int)=0;
    void bfs(int);
};

#endif

GraphMatrix.h

#ifndef _GRAPHMATRIX__H_
#define _GRAPHMATRIX__H_
#include"Vector.h"
#include"Graph.h"
#include"Queue.h"
#include<string>
//城市
struct city
{
    string cname;
    city(string name){cname=name;}
};
//道路
struct road
{
    road(){}
};
//顶点对象
template <typename Tv>
struct Vertex{
    Tv data;
    int inDegree,outDegree;
    VStatus status;
    int dTime,fTime;
    int parent;
    int priority;
    Vertex(Tv const& d=(Tv)0):
    data(d),inDegree(0),outDegree(0),status(UNDISCOVERED),dTime(-1),fTime(-1),parent(-1),priority(INT_MAX){}
};

//边对象
template<typename Te>
struct Edge{
    Te data;
    int weight;
    EType type;
    Edge(Te const& d,int w):data(d),weight(w),type(UNDETERMINED){}
};
//邻接矩阵
template<typename Tv,typename Te>
class GraphMatrix:public Graph<Tv,Te>{
private:
    Vector<Vertex<Tv>>V;//顶点集（向量)
    Vector<Vector<Edge<Te>*>>E;//边集（邻接矩阵）
public:
    GraphMatrix(){n=e=0;}
    ~GraphMatrix(){
        for(int j=0;j<n;j++)
            for(int k=0;k<n;k++)
                delete E[j][k];
    }
    //顶点基本操作：查询第i个顶点
    virtual Tv& vertex(int i){return V[i].data;}
    virtual int inDegree(int i){return V[i].inDegree;}
    virtual int outDegree(int i){return V[i].outDegree;}
    virtual int firstNbr(int i){return nextNbr(i,n);}
    virtual int nextNbr(int i,int j)
    {
        while((-1<j)&&(!exist(i,--j)));
        return j;
    }
    virtual VStatus& status(int i){return V[i].status;}
    virtual int& dTime(int i){return V[i].dTime;}
    virtual int& fTime(int i){return V[i].fTime;}
    virtual int& parent(int i){return V[i].parent;}
    virtual int& priority(int i){return V[i].priority;}
    //顶点动态操作
    virtual int insert(Tv const& vertex)
    {
        for(int j=0;j<n;j++)//各顶点预留潜在边
            E[j].insert(NULL);
        n++;
        E.insert(Vector<Edge<Te>*>(n,n,(Edge<Te>*)NULL));//创建顶点对应边向量
        return V.insert(Vertex<Tv>(vertex));//顶点向量增加顶点
    }
    virtual Tv remove(int i)
    {
        for(int j=0;j<n;j++)//出边
            if(exists(i,j))
            {
                delete E[i][j];
                V[j].inDegree--;
            }
        E.remove(i);
        n--;
        Tv vBak=vertex(i);
        V.remove(i);
        for(int j=0;j<n;j++)//入边
            if(Edge<Te> * e=E[j].remove(i))
            {
                delete e;
                V[j].outDegree--;
            }
        return vBak;
    }
    //边的确认操作
    virtual bool exists(int i,int j)
    {
        return (0<=i)&&(i<n)&&(0<=j)&&(j<n)&&E[i][j]!=NULL;
    }
    //查询i,j联边
    virtual EType& type(int i,int j){return E[i][j]->type;}
    virtual Te& edge(int i,int j){return E[i][j]->data;}
    virtual int& weight(int i,int j){return E[i][j]->weight;}
    //边的动态操作
    virtual void insert(Te const& edge,int w,int i,int j)
    {
        if(exists(i,j)) return;
        E[i][j]=new Edge<Te>(edge,w);
        e++;
        V[i].outDegree++;
        V[j].inDegree++;
    }
    virtual Te remove(int i,int j)
    {
        Te eBak=edge(i,j);
        delete E[i][j];
        E[i][j]=NULL;
        e--;
        V[i].outDegree--;
        V[j].inDegree--;
        return eBak;
    }
};
//广度优先搜索
template<typename Tv,typename Te>
void Graph<Tv,Te>::BFS(int v,int& clock)
{
    Queue<int> Q;
    status(v)=DISCOVERED;
    Q.enqueue(v);
    while(!Q.empty())//不断取出队首，考察邻居
    {
        int v=Q.dequeue();
        dTime(v)=++colok;
        for(int u=firstNbr(v);-1<u;u=nextNbr(v,u))
            if(UNDISCOVERED==status(u))
            {//若未发现
                status(u)=DISCOVERED;
                Q.enqueue(u);
                type(v,u)=Tree;
                parent(u)=v;
            }
            else
                type(v,u)=CROSS;
        status(v)=VISITED;
    }
}
#endif

Vector.h

#ifndef __Vector_H__
#define __Vector_H__
#include <iostream>
using namespace std;
#include <ctime>
#include<stdlib.h>

typedef int Rank; //秩
#define DEFAULT_CAPACITY  3 //默认的初始容量（实际应用中可设置为更大）

template <typename T>
class Vector 
{
protected:
    Rank _size;int _capacity;T* _elem;
    void expand();
    void shrink();
    
public:
    Vector(int c=DEFAULT_CAPACITY,int s=0,T v=0)//构造
    {_elem=new T[_capacity=c];for(_size=0;_size<s;_elem[_size++]=v);}
    ~Vector(){delete []_elem;}//析构
    T& operator[] (Rank r);
    Rank size() const{return _size;};
    bool empty(){return !size();}
    Rank insert(Rank r,T const& e);
    Rank insert(T const& e){return insert(_size,e);}
    void show();
    T remove(Rank r);
    int remove(Rank lo,Rank hi);
    Rank find (T const& e){return find(e,0,_size);}
    Rank find (T const &e,Rank lo,Rank hi);
    void swap(T &a,T &b);
    void BubbleSort_down(T A[],int n);
    void BubbleSort_up(T A[],int n);
    void mergeSort(Rank lo,Rank hi);
    void merge(Rank lo,Rank mi,Rank hi);
};

//扩容
template <typename T>
void Vector<T>::expand()
{
    if(_capacity<DEFAULT_CAPACITY)
        _capacity=DEFAULT_CAPACITY;
    if(_size<_capacity)
        return;
    T* _OldElem=_elem;
    _elem=new T[_capacity<<=1];
    for(int i=0;i<_size;i++)
        _elem[i]=_OldElem[i];
    delete [] _OldElem;
}

//缩容
template <typename T>
void Vector<T>::shrink()
{
    if(_capacity<DEFAULT_CAPACITY<<1)
        return;
    if(_size>_capacity>>2)
        return;
    T* _OldElem=_elem;
    _elem=new T[_capacity>>=1];
    for(int i=0;i<_size;i++)
        _elem[i]=_OldElem[i];
    delete [] _OldElem;
}

template <typename T> 
T& Vector<T>::operator[] (Rank r) //重载下标操作符
{
    return _elem[r];
} // assert: 0 <= r < _size
//展示
template<typename T>
void Vector<T>::show()
{
    for(int i=0;i<_size;i++)
        cout<<_elem[i]<<" ";
    cout<<endl;
}

//插入
template<typename T>
Rank Vector<T>::insert(Rank r,T const& e)
{
    expand();
    if(r<0||r>_size)
    {cout<<"ERROR!"<<endl;return -1;}
    for(int i=_size;i>r;i--)
        _elem[i]=_elem[i-1];
    _elem[r]=e;
    _size++;
    return r;
}
//区间删除
template<typename T>
int Vector<T>::remove(Rank lo,Rank hi)
{
    if(hi==lo)
        return 0;
    while(hi<_size)
        _elem[lo++]=_elem[hi++];
    _size=lo;
    shrink();
    return hi-lo;
}
//单个删除
template<typename T>
T Vector<T>::remove(Rank r)
{
    T e=_elem[r];
    remove(r,r+1);
    return e;
}
//区间查找
template<typename T>
Rank Vector<T>::find (T const &e,Rank lo,Rank hi)
{
    while((lo<hi--)&&(e!=_elem[hi]));
    return hi;
}

//交换
template<typename T>
void Vector<T>::swap(T &a,T &b)
{
    T c;
    c=a;
    a=b;
    b=c;
}

//冒泡降序
template <typename T>
void Vector<T>::BubbleSort_down(T A[],int n)
{
    bool sorted=false;
    while(!sorted)
    {
        sorted=true;
        for(int i=0;i<n-1;i++)
        {
            if(A[i]<A[i+1])
            {
                swap(A[i],A[i+1]);
                sorted=false;
            }
        }
        n--;
    }
}

//冒泡升序
template <typename T>
void Vector<T>::BubbleSort_up(T A[],int n)
{
    bool sorted=false;
    while(!sorted)
    {
        sorted=true;
        for(int i=0;i<n-1;i++)
        {
            if(A[i]>A[i+1])
            {
                swap(A[i],A[i+1]);
                sorted=false;
            }
        }
        n--;
    }
}
//归并排序
template <typename T>
void Vector<T>::mergeSort(Rank lo,Rank hi)
{
    if(hi-lo<2)return;
    Rank mi=(hi+lo)>>1;
    mergeSort(lo,mi);
    mergeSort(mi,hi);
    merge(lo,mi,hi);
}
//归并
template <typename T>
void Vector<T>::merge(Rank lo,Rank mi,Rank hi)
{
    T* A=_elem+lo;
    int lb=mi-lo;
    T* B=new T[lb];
    for(Rank i=0;i<lb;i++)
        B[i]=A[i];
    int lc=hi-mi;
    T* C=_elem+mi;
    for(Rank i=0,j=0,k=0;(j<lb)||(k<lc);)
    {
        //cout<<A[i]<<" "<<B[j]<<" "<<C[k]<<" ";
        if((j<lb)&&(!(k<lc)||B[j]<=C[k]))
            A[i++]=B[j++];
        if((k<lc)&&(!(j<lb)||C[k]<B[j]))
            A[i++]=C[k++];
        //cout<<A[i]<<" "<<B[j]<<" "<<C[k]<<" ";
    }
    delete [] B;
}

#endif

ListNode.h

#ifndef  __ListNode_H__
#define __ListNode_H__
#include <iostream>
using namespace std;
#define Posi(T) ListNode<T>*
typedef int Rank;

//结点
template <typename T>
struct ListNode{
    T data;
    Posi(T) pred;
    Posi(T) succ;
    ListNode() {};
    ListNode (T e,Posi(T) p=NULL,Posi(T) s=NULL)
    {
        data=e;pred=p;succ=s;
    }
    Posi(T) insertAsSucc(T const &e);
    Posi(T) insertAsPred(T const &e);
    
};

//后插入
template <typename T>
Posi(T) ListNode<T>::insertAsSucc(T const &e)
{
    Posi(T) x=new ListNode(e,this,succ);
    succ->pred=x;succ=x;
    return x;
}

//前插入
template <typename T>
Posi(T) ListNode<T>::insertAsPred(T const &e)
{
    Posi(T) x=new ListNode(e,pred,this);
    pred->succ=x;pred=x;
    return x;
}
#endif

List.h

#ifndef __List_H__
#define __List_H__
#include"ListNode.h"

template<typename T>
class List{
private:
    int _size;
    Posi(T) header;
    Posi(T) trailer;

public:
    List(){Init();}
    ~List(){};
    void Init();
    Rank size(){return _size;}
    bool empty(){return _size<=0;}
    int clear();
    T Data(Posi(T) p){return p->data;}
    Posi(T) first() const{return header->succ;}
    Posi(T) last() const{return trailer->pred;}
    Posi(T) insertA(Posi(T) p,T const &e);
    Posi(T) insertB(Posi(T) p,T const &e);
    Posi(T) insertAsFist(T const &e);
    Posi(T) insertAsLast(T const &e);
    void show();
    T remove(Posi(T) p);
    Posi(T) find(T const &e);
    Posi(T) search(T const &e,int n, Posi(T) p);
    void insertSort(Posi(T) p,int n);
    T Search(T const &e);
    int Place(int place){return place;}

};
//初始化
template<typename T>
void List<T>::Init()
{
    header=new ListNode<T>;
    trailer=new ListNode<T>;
    header->succ=trailer;header->pred=NULL;
    trailer->pred=header;trailer->succ=NULL;
    _size=0;
}


//首节点插入
template<typename T>
Posi(T) List<T>::insertAsFist(T const &e)
{
    _size++;
    return header->insertAsSucc(e);
}
//末节点插入
template<typename T>
Posi(T) List<T>::insertAsLast(T const &e)
{
    _size++;
    return trailer->insertAsPred(e);
}
//后插入
template<typename T>
Posi(T) List<T>::insertA(Posi(T) p,T const &e)
{
    _size++;
    return p->insertAsSucc(e);
}

//前插入
template<typename T>
Posi(T) List<T>::insertB(Posi(T) p,T const &e)
{
    _size++;
    return p->insertAsPred(e);
}
//展示
template<typename T>
void List<T>::show()
{
    Posi(T) p=trailer->pred;;
    while(p->pred)
    {
        cout<<p->data<<" ";
        p=p->pred;
    }
    cout<<endl;
}
//查找
template<typename T>
Posi(T) List<T>::find(T const &e)
{
    Posi(T) p=header->succ;
    while(p->succ)
    {
        if(p->data==e)
            return p;
        p=p->succ;
    }
    return NULL;
}
//删除
template<typename T>
T List<T>::remove(Posi(T) p)
{
    T e=p->data;
    p->pred->succ=p->succ;
    p->succ->pred=p->pred;
    delete p;
    _size--;
    return e;
}
//清空
template<typename T>
int List<T>::clear()
{
    int _oldSize=_size;
    while(0<_size)
        remove(header->succ);
    return _oldSize;
}
//查找不大于e最后一个元素
template<typename T>
Posi(T) List<T>::search(T const &e,int n, Posi(T) p)
{
    while(0<=n--)
    {
        p=p->pred;
        if(p->data<=e)
            break;
    }
    return p;
}

//插入排序
template<typename T>
void List<T>::insertSort(Posi(T) p,int n)
{
    for(int r=0;r<n;r++)
    {
        insertA(search(p->data,r,p),p->data);
        p=p->succ;
        remove(p->pred);
    }
}
//查找大于e第一个元素
template<typename T>
T List<T>::Search(T const &e)
{
    Posi(T) p=header->succ;
    while(p->succ)
    {
        if(p->data>e)
            return p->data;
        p=p->succ;
    }
    return NULL;
}

#endif

Queue.h

#ifndef __Queue_H__
#define __Queue_H__
#include"List.h"
template <typename T> 
class Queue:public List<T>{
public:
    void enqueue(T const &e)//尾入队
    {
        insertAsLast(e);
    }
    T dequeue()//首出队
    {
        return remove(first());
    }
    T& front()
    {
        return first()->data;
    }
    T& final()
    {
        return last()->data;
    }
};

#endif

写回答
好问题 0 提建议
追加酬金
关注问题
分享
邀请回答
编辑收藏删除
收藏举报

10条回答默认最新

关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
叫兽-郭老师 Java领域新星创作者 2023-12-13 22:24
关注
由人工智能和答主提供，可以参考如下，如果回答的不正确，及时评论区回复，我追加回答，谢谢。

在这段代码中，主要存在以下几个问题：

在GraphMatrix类的insert方法中，你试图将一个整数插入到一个Vertex对象中，但是Vertex类并没有定义接受整数作为参数的构造函数。这将导致编译错误。

在main函数中，你试图创建一个GraphMatrix对象并调用其insert方法，但是这个方法并不存在。你应该调用GraphMatrix类中定义的其他方法，例如insertT。

在GraphMatrix类的remove方法中，你试图删除一个不存在的边。你需要确保在尝试删除边之前，该边确实存在。

在GraphMatrix类的vertex方法中，你试图访问一个不存在的顶点。你需要确保在尝试访问顶点之前，该顶点确实存在。

在GraphMatrix类的exists方法中，你试图检查一个不存在的边或顶点是否存在。你需要确保在尝试检查之前，该边或顶点确实存在。

在GraphMatrix类的type和edge方法中，你试图访问一个不存在的边的类型或数据。你需要确保在尝试访问之前，该边确实存在。

在GraphMatrix类的bfs方法中，你没有正确地初始化时钟变量。你应该在每次循环开始时重置时钟变量，而不是在整个循环结束后重置。

在Vector类的BubbleSort_down和BubbleSort_up方法中，你没有正确地更新交换标志。你应该在每次交换元素后更新交换标志，以便在下一次循环中可以继续进行冒泡排序。

在Vector类的mergeSort方法中，你没有正确地合并两个子数组。你应该在每次合并两个子数组后更新合并后的数组，以便在下一次循环中可以继续进行归并排序。

在ListNode.h和List.h头文件中，你没有正确地声明和使用模板类和方法。你应该在每个类和方法的定义前添加正确的模板声明，并在使用这些类和方法的地方提供正确的模板参数。
本回答被题主选为最佳回答 , 对您是否有帮助呢?

解决 2
无用
评论打赏
分享
举报

评论

按下Enter换行，Ctrl+Enter发表内容

查看更多回答(9条)

报告相同问题？

关注问题

尚不存在的对象的竞争条件
2019-04-02 07:29

回答 1 已采纳 Race detector detects that you concurrently read and write the same address in memory. It is by d
【遇见的错误】tempCodeRunnerFile.c:error: expected declaration specifiers or ‘...‘ before ‘某个字符‘token
2022-11-17 15:17

好学的小冷的博客在头文字调用时出现 tempCodeRunnerFile.c:error: expected declaration specifiers or '...' before '某个字符'token 的解决办法
tempc.c
2022-11-08 16:17

tempc.c
DS18B20 介绍及案例程序.docx
2024-07-18 22:59

1. **库导入**：使用 `#include <OneWire.h>` 和 `#include <DallasTemperature.h>` 导入库文件，以便于使用 DS18B20 的相关功能。 2. **定义引脚**：通过 `#define ONE_WIRE_BUS 2` 定义数据线连接的 Arduino 数字...
提示错误如下TypeError: unsupported operand type(s) for +=: ‘gurobipy.LinExpr‘ and ‘tupledict‘
2023-02-10 10:53

sxyjy123的博客无
18B20温度传感器使用教程.rar-综合文档
2021-05-23 19:38

《18B20温度传感器使用教程》 18B20是一款由Dallas Semiconductor（现Maxim Integrated）生产的数字温度传感器，它具有高精度、低功耗和串行通信的特点，广泛应用于各种需要精确温度测量的场合，如智能家居、工业...
MD5加密算法的实现（代码+思路--＞参考其他博客＋修改）
2021-07-07 17:10

hbu_xbfp的博客 bits/stdc++.h> using namespace std; #define SHIFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) #define F(x, y, z) (((x) & (y)) | ((~x) & (z))) #define G(x, y, z) (((x) & (z)) |...
sensors:Raspberry Pi上的传感器
2021-04-04 01:27

感测器 ... 然后，这些数据由Telegraf收集，并由Grafana中的仪表板提供。... 注意：tempC的准确度未知。 MHZ19C传感器在计算CO2浓度时需要知道温度以进行校正。当我在寒冷的室外环境（〜7C）中尝试时，它
【C语言】基本算法系列1：数字转字符串
2022-10-30 10:45

pentiumcpu的博客江湖不是打打杀杀，程序员开发不仅Ctrl CVC语言开发过程中如遇到数字转字符串，可以使用itoa函数，itoa是广泛使用的非标准C语言和C++语言扩展功能。但因为它是一个非标准的C / C++语言功能,因此不能好好的被所有...
DS18B20温度传感器实验,ds18b20温度传感器实验报告,C,C++源码.rar
2021-10-10 21:51

DS18B20是一款由Dallas Semiconductor（现Maxim Integrated）生产的数字温度传感器，它能够直接输出数字信号，无需A/D转换器。这个传感器广泛应用于各种环境监测、智能家居、工控系统等领域，因其高精度、单线通信和...
python error：TypeError: unsupported operand type(s) for +=: ‘builtin_function_or_method‘ and ‘int‘
2020-12-17 15:24

鹏鹏写代码的博客问题描述：关于python报错：TypeError: unsupported operand type(s) for +=: ‘builtin_function_or_method’ and 'int’ 错误展示： ...如果我们用C语言写： #include<stdio.h> int main() { int
DS18B20 for Arduino 1.0.zip
2023-12-19 17:27

标题 "DS18B20 for Arduino 1.0.zip" 暗示了这是一个针对Arduino平台的DS18B20温度传感器的库或教程资料。DS18B20是一款数字温度传感器，由Dallas Semiconductor（现Maxim Integrated）制造，它允许用户通过单线接口...
全栈开发：TypeScript、React、Next.js、MongoDB、Docker 完全教程指南 - 第七章 MongoDB和Mongoose
2024-11-05 14:00

Lee达森的博客 export async function findByZip( paramZip: string ): Promise | null> { try { return await WeatherModel.findOne({ zip: paramZip }); } catch (err) { console.log(err); } return []; } 示例 7-6：通过...
latex编译时报错：runaway argument？
2021-01-03 11:01

一只爱吃醋的鱼的博客 latex编译时报错：runaway argument？今天使用WinEdt排版时出现 runaway argument？的错误提示，查阅资料发现是table多次定义，最后删除文件夹里除了Tex之外所有文件（如log、bbl、blg、out、synctex等），重新编译...
Weather-Report:输入世界上任何城市的名称，它将告诉您当前该城市的温度和天气
2021-05-20 17:31

.catch(error => console.error('Error:', error)); ``` 3. **数据解析**：获取到的数据通常是JSON格式，我们需要将其解析成JavaScript对象，以便处理和展示。`response.json()`方法会返回一个Promise，我们可以...
C练题笔记之：牛客-HJ019.简单错误记录
2021-07-04 23:12

不服输的小悦阳的博客 1、记录最多8条错误记录，循环记录，最后只用输出最后出现的八条错误记录。对相同的错误记录只记录一条，但是错误计数增加。最后一个斜杠后面的带后缀名的部分（保留最后16位）和行号完全匹配的记录才做算是”相同...
TinyCircuits-BMA250-library:Arduino的BMA250库
2021-03-26 22:51

int begin（uint8_t范围，uint8_t带宽）输入加速度读数的范围（±2 /±4g /±8g /±16g）和低通滤波器带宽1kHz-<8Hz，以将加速度计初始化为适当的读数模式 void read（）读取并分配BMA250类变量X ， Y ， Z和...
testbench文件显示波形_在testbench从文件读入激励
2020-12-24 01:50

另个名字是Larry的博客 $finish at simulation time 400 V C S S i m u l a t i o n R e p o r t 在verdi中装入dump.vcd,波形如下：修改testbench代码，用fdisplay把输出写到文件里面。 `timescale 1ns/1ns `include "adder4.v" ...
使用最新TexLive2020+VsCode来编写Latex论文（假设使用：CVPR2018）
2020-05-07 18:00

Yuuki-Asuna的博客 "%DOCFILE%" ] } ], "sync.quietSync": true, "latex-workshop.latex.autoClean.run": "onBuilt", "files.associations": { } } 新建一个文件test.tex 复制粘贴这个文件 \documentclass[10pt,twocolumn,letterpaper]...
C++：计算非整数阶的贝塞尔 J 函数(附完整源码)
2022-12-22 14:37

源代码大师的博客 static double x_vec[N_MAX] = { 0.2E+00, 1.0E+00, 2.0E+00, 2.5E+00, 3.0E+00, 5.0E+00, 10.0E+00, 20.0E+00, 1.0E+00, 2.0E+00, 5.0E+00, 10.0E+00, 50.0E+00, 1.0E+00, 2.0E+00, 5.0E+00, 10.0E+00, 50.0E+00, ...
没有解决我的问题, 去提问

问题事件

关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
已结题（查看结题原因） 12月15日
关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
已采纳回答 12月15日
关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
赞助了问题酬金15元 12月13日
关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
创建了问题 12月13日

悬赏问题

¥20 三极管1000倍放大电路
¥15 vscode报错如何解决
¥15 前端vue CryptoJS Aes CBC加密后端java解密
¥15 python随机森林对两个excel表格读取，shap报错
¥15 基于STM32心率血氧监测（OLED显示）相关代码运行成功后烧录成功OLED显示屏不显示的原因是什么
¥100 X轴为分离变量（因子变量），如何控制X轴每个分类变量的长度。
¥30 求给定范围的全体素数p的(p-2)/p的连乘积值
¥15 VFP如何使用阿里TTS实现文字转语音？
¥100 需要跳转番茄畅听app的adb命令
¥50 寻找一位有逆向游戏盾sdk 应用程序经验的技术

1>e:\tempc++\test10\test10\vector.h(20): error C2440: “default argument”: 无法从“int”转换为“Vertex<Tv>”

10条回答 默认 最新

问题事件

悬赏问题

10条回答默认最新