精华内容
下载资源
问答
  • Java语言基础知识_1.3:数组

    千次阅读 2019-05-14 22:36:13
    1. 关于Java中数组的说法正确的是: 数组可以动态初始化 数组可以赋值给Object类型的对象 数组可以调用Object类的所有方法 ...2. 对于数组的声明与使用下列说法正确的是: 对于声明 String s...

    1. 关于Java中数组的说法正确的是:

    1. 数组可以动态初始化
    2. 数组可以赋值给Object类型的对象
    3. 数组可以调用Object类的所有方法

    数组创建以后,其长度可以修改

    Java中的数组的定义就是相同类型 ,固定长度的一组数据,一旦被初始化,长度不可更改。

    参考文章:java 中数组的长度可以改变么?

     

    2. 对于数组的声明与使用,下列说法正确的是:

    对于声明 String str[];

    (1) 上述声明错误,声明必须指定数组元素的个数

    (2) 上述声明正确,声明时,无须指定数组元素的格式

    (3)上述声明完成后,java就给str的数组元素分配了内存

    (4) 上述声明完成后,java没给str的数组元素分配内存

    (5) 上述声明完成后,数组名可以直接使用,给指定数组元素赋值

    (6) 上述声明完成后,数组名不能直接使用,需要初始化后才能使用

     

    3. 对于数组的使用,以下做法正确的是:

    • int a[]={1,2,3}

    int a[10]=new int[10]; a[10]=1;a[1]=1;

    int a[10]={1,”2”,3};

    int a[10]; a[1]=0

     

     

    4. 关于二维数组的创建,以下做法正确的是:

    • int a[][] =new int[4][5]
    • int a[][] =new int[4][]; a[0]=new int[10];a[1]=new int[20];

    int a[][]; a=new int[3][]; a[0]=new int[3]; a[1]={1,2};a[2]={1,2,3};

    a[0]=new int[3] 是为最高维分配引用空间,也就是为最高维限制其能保存数据的最长的长度。

    然后再为其每个数组元素单独分配空间 a0=new String("Good") 等操作。

    参考文章:Java 数组

     

     

    5. 关于下面的程序,哪个结论是正确的()

    public class Test{
    
    public static void main(String args[]){
    
    int a[]=new int[5];
    
    a.length = 10;
    
    System.out.println(a.length)
    
    }
    
    }

    程序无法通过编译程序

     

    6. 对于下列代码

    String str1=”java”;
    
    String str2=”java”;
    
    String str3 = new String(“java”);
    
    StringBuffer str4 = new StringBuffer(“java”);

    以下表达式的值为true的是()

    str1==str2

     

    7. 下列声明二维数组的语句不合法的是()

    char c[][] = new char[2][3];

    char c[][]=new char[6][];

    char[][] c= new char[3][3];

    char [][] c = new char[][4]

    展开全文
  • 正确使用虚函数,需要满足下列条件: (1)具有符合类型兼容规则公有派生类层次结构。 (2)在派生类中重新定义基类虚函数,对其进行覆盖。 (3)通过基类指针或基类引用访问虚函数。 1、题目内容: 定义抽象...

    使用虚函数是实现动态联编的基础。正确使用虚函数,需要满足下列条件:
    (1)具有符合类型兼容规则的公有派生类层次结构。
    (2)在派生类中重新定义基类的虚函数,对其进行覆盖。
    (3)通过基类指针或基类引用访问虚函数。

    1、题目内容:
    定义抽象基类Shape, 其中纯虚函数printName()输出几何图形的名称和相应的成员数据、纯虚函数printArea()计算几何图形的面积。并由Shape类派生出5个派生类:Circle(圆形),数据成员为半径、Square(正方形) ,数据成员为边长、Rectangle(长方形) ,数据成员为长和宽、Trapezoid(梯形) ,数据成员为上底、下底和高、Triangle(三角形) ,数据成员为底和高。测试过程,定义一个指向基类的指针数组,使其每个元素指向一个动态产生的派生类对象,分别调用相应的成员函数显示各个几何图形的属性及面积,最终输出总面积值。

    输入格式:
    依次输入圆半径、正方形边长、长方形长宽、梯形上底下底和高、三角形底边和高,均为实数。

    输出格式:
    请参考输出样例,建议直接复制样例中的部分文字粘贴进自己的代码。圆周率取 3.14159
    注意输出中的标点符号、空格。
    输入样例:
    10
    5
    2 4
    1 2 3
    4 3

    输出样例:
    圆:半径=10,面积:314.159
    正方形:边长=5,面积:25
    长方形:长=2,宽=4,面积:8
    梯形:上底=1,下底=2,高=3,面积:4.5
    三角形:底边=4,高=3,面积:6
    总面积:357.659

    #include<iostream>
    using namespace std;
    class shape
    {
    public:
    	virtual void printname()=0;//纯虚函数
        virtual double printarea()=0;//纯虚函数
    };
    class circle:public shape
    {
    private:
    	double r;
    public:
    	circle(double R){r=R;}
        void printname()
    	{cout<<"圆:半径="<<r;}
    	double printarea()
    	{cout<<",面积:"<<r*r*3.14159<<endl;return r*r*3.14159;}
    };
    class square:public shape
    {
    private:
    	double a;
    public:
    	square(double A){a=A;}
    	void printname()
    	{cout<<"正方形:边长="<<a;}
    	double printarea()
    	{cout<<",面积:"<<a*a<<endl;return a*a;}
    };
    class rectangle:public shape
    {
    private:
    	double a,b;
    public:
    	rectangle(double A,double B){a=A;b=B;}
    	void printname()
    	{cout<<"长方形:长="<<a<<",宽="<<b;}
    	double printarea()
    	{cout<<",面积:"<<a*b<<endl;return a*b;}
    };
    class trapezoid:public shape
    {
    private:
    	double d1,d2,h;
    public:
    	trapezoid(double D1,double D2,double H){d1=D1;d2=D2;h=H;}
    	void printname()
    	{cout<<"梯形:上底="<<d1<<",下底="<<d2<<",高="<<h;}
    	double printarea()
    	{cout<<",面积:"<<(d1+d2)*h/2.0<<endl;return (d1+d2)*h/2.0; }
    };
    class triangle:public shape
    {
    private:
    	double d,h;
    public:
    	triangle(double D ,double H){d=D;h=H;}
    	void printname()
    	{cout<<"三角形:底边="<<d<<",高="<<h;}
    	double printarea()
    	{cout<<",面积:"<<d*h/2.0<<endl;return d*h/2.0;}
    };
    int main()
    {
    	int i;
    	shape *p[5];//定义一个指向基类的指针数组,使其每个元素指向一个动态产生的派生类对象,也可以用基类引用
    	double r,t=0;
         cin>>r;
    	p[0]=new circle(r);//动态分配对象
    	double a;
    	cin>>a;
    	p[1]=new square(a);//动态分配对象
    	double b;
    	cin>>a>>b;
    	p[2]=new rectangle(a,b);//动态分配对象
    	double h;
    	cin>>a>>b>>h;
    	p[3]=new trapezoid(a,b,h);//动态分配对象
    	cin>>a>>b;
    	p[4]=new triangle(a,b);//动态分配对象
    	for(i=0;i<5;i++)
    	{
    		p[i]->printname();
    		t+=p[i]->printarea();
    		delete p[i];//释放,隐含了对析构函数的调用
    	}
    	cout<<"总面积:"<<t<<endl;   
    	return 0;
    }
    

    在这里插入图片描述

    2.、抽象宠物类的实现
    题目内容:
    定义抽象宠物类Pet,其中数据成员包括:名字,年龄和颜色;成员函数包括:构造函数;获取成员数据值的函数;纯虚函数Speak和纯虚函数GetInfo; 定义Pet的派生类Cat和Dog,其中Speak函数分别显示猫和狗的叫声,而GetInfo函数分别输出Cat和Dog的属性。主函数中定义Pet指针变量,分别指向动态生成的Cat和Dog对象,并通过指针分别调用GetInfo函数和Speak函数,观察并分析输出结果。

    输入格式:
    猫和狗的信息

    输出格式:
    请参考输出样例,严格遵照格式要求输出,建议直接复制样例中的部分文字粘贴进自己的代码中.(冒号是英文冒号,冒号后无空格)

    输入样例:
    mikey 2 blue
    benben 1 black

    输出样例:
    猫的名字:mikey
    猫的年龄:2
    猫的颜色:blue
    猫的叫声:miao!miao!
    狗的名字:benben
    狗的年龄:1
    狗的颜色:black
    狗的叫声:wang!wang!

    #include<iostream>
    using namespace std;
    class pet
    {
    protected:
    	char name[10],color[10];
    	int age;
    public:
    	pet(char Name[10],int Age,char Color[10]){strcpy(name,Name);age=Age;strcpy(color,Color);cout<<"pet类构造函数调用完毕"<<endl;}
        virtual ~pet(){cout<<"pet类析构函数调用完毕"<<endl;}
    	char*getname(){return name;}
    	char*getcolor(){return color;}
    	int getage(){return age;}
    	virtual void speak()=0;
    	virtual void getinfo()=0;
    };
    class cat:public pet
    {
    public:
    	cat(char Name[10],int Age,char Color[10]):pet(Name,Age,Color){cout<<"cat类构造函数调用完毕"<<endl;}
    	virtual ~cat(){cout<<"cat类析构函数调用完毕"<<endl;}
        virtual void speak()
    	{cout<<"猫的叫声:miao!miao!"<<endl;}
        virtual void getinfo()
    	{	
    		cout<<"猫的名字:"<<getname()<<endl;
    		cout<<"猫的年龄:"<<getage()<<endl;
    		cout<<"猫的颜色:"<<getcolor()<<endl;
    	}
    };
    class dog:public pet
    {
    public:
    	dog(char Name[10],int Age,char Color[10]):pet(Name,Age,Color){cout<<"dog类构造函数调用完毕"<<endl;}
    	virtual ~dog(){cout<<"dog类析构函数调用完毕"<<endl;}
        virtual void speak()
    	{cout<<"狗的叫声:wang!wang!"<<endl;}
        virtual void getinfo()
    	{
    		cout<<"狗的名字:"<<getname()<<endl;
    		cout<<"狗的年龄:"<<getage()<<endl;
    		cout<<"狗的颜色:"<<getcolor()<<endl;
    	}
    };
    int main()
    {
    	pet *p;
    	char name[10],co[10];
    	int age;
    	cin>>name>>age>>co;
    	p=new cat(name,age,co);
    	p->getinfo();
    	p->speak();
    	cin>>name>>age>>co;
    	p=new dog(name,age,co);
    	p->getinfo();
    	p->speak();
    	return 0;
    }
    
    

    在这里插入图片描述

    展开全文
  • 1.下列哪一个是析构函数特征() 正确答案: B A析构函数定义只能在类体内 (析构可以在类外定义) B一个类中只能定义一个析构函数 ...”,要释放p所指向的动态内存,应使用语句( ) 正确答案:...

    1.下列哪一个是析构函数的特征()
    正确答案: B   
    A析构函数定义只能在类体内               (析构可以在类外定义)
    B一个类中只能定义一个析构函数        
    C析构函数名与类名不同                   (要与类名相同, 前面加~)
    D析构函数可以有一个或多个参数           (析构函数不需要参数,也没有返回类型,不需要重载)

     

    2.假定指针变量p定义为“int *p=new int(100);”,要释放p所指向的动态内存,应使用语句( )
    正确答案: A   你的答案: D
    A delete p;
    B delete *p;
    C delete &p;
    D delete []p;
    int* p = new int (100) 是创建一个int型的内存,并赋值为100; 
    int *p = new int[100] 是创建100个int型的内存;
    一般用法是new一个数组的话一般是delete [] 其他的直接delete即可。
    但是其实对于内置数据类型,其实是delete[] 和delete都可以的。

     

    3.关于函数输入参数的正确描述都有哪些?() 

    正确答案: A C D   你的答案: B C

    A始终用const限制所有指向只读输入参数的指针和引用

    B值传递只用于原始类型(int,float...)的输入参数 (值传递可以传递类对象)

    C优先按const的引用取得其他用户定义类型的输入 (常量的引用可以提高程序的执行效率,无需创建参数的副本)

    D如果函数需要修改其参数副本,则可以考虑通过值传递代替通过引用传递

    (副本就是形参,传形参时通过值传递创建副本,不改变主调函数的实参,传递引用时可能伴随着主调函数实参被修改)

     

    4.C++中,能作为函数重载判断依据的是?

    正确答案: A B C   你的答案: A C

    A 参数类型

    B Const   如果同时在类中,对于函数名相同的const函数和非const函数能够构成重载

    如果定义的对象是常对象,则调用的是const成员函数;如果定义的对象是非常对象,则调用重载的非const成员函数。

    C 参数个数

    D 返回类型

    函数重载,是指同一个函数名可以对应多个函数的实现。进行函数重载时,要求同名函数在参数个数上不同,或者参数类型上不同。即重载函数不许具有相同的形参列表。因为函数并不会总是有返回值, 函数的返回类型不能作为函数重载的判断依据。const是函数的一部分参与函数的重载

     

     

    5.请问下列代码的输出是多少()

    
    #include <stdio.h>
    int main()
    {
        int m []={1,2,3,4,5,6,7,8,9,0};
        int(*p)[4]=(int(*)[4])m;
        printf(“%”,p[1][2]);
        return 0;
    }
    
    

    正确答案: A   你的答案: 空

    A 7

    B 3

    C 8

    D 4

    int *p[4];  //定义一个指针数组,该数组中每个元素是一个指针,每个指针指向哪里就需要程序中后续再定义了。
    int (*p)[4];  //定义一个数组指针,该指针指向含4个元素的一维数组(数组中每个元素是int型)。
    数组指针也称指向一维数组的指针,也称行指针
     
    区分int *p[n]; 和int (*p)[n]; 就要看运算符的优先级了。
    int *p[n]; 中,运算符[ ]优先级高,先与p结合成为一个数组,再由int*说明这是一个整型指针数组。
    int (*p)[n]; 中( )优先级高,首先说明p是一个指针,指向一个整型的一维数组。
    1、int (*p)[4]:定义一个数组指针,该指针指向含4个元素的一维数组(数组中每个元素是int型); 2、(int (*)[4])m:表示将m强制转换为大小为4的数组指针;
    
    
    int (*p)[4] : 表示行指针,单位移动量为4个int类型。即p+1,则一次移动4个int类型
    (int (*)[4])m : 表示以数组指针类型组织m,每4个为一个数组
    
    m为{{1,2,3,4},{5,6,7,8},{9,0,,}}
    p指向第一行
    故p[1][2]即*(*(p+1)+2)表示第二行第三个元素

     

    6.以下程序的输出是

    class Base {
        public:
        Base(int j): i(j)  {}
        virtual~Base() {}               //析构函数
        void func1() {
            i *= 10;
            func2();
        }
        int getValue() {
            return  i;
        }
        protected:
        virtual void func2() {         //虚函数
            i++;
        }
        protected:
        int i;
    };
    class Child: public Base {
        public:
        Child(int j): Base(j) {}
        void func1() {
            i *= 100;
            func2();
        }
        protected:
        void func2() {
            i += 2;
        }
    };
    int main() {
        Base * pb = new Child(1);       //创建子类对象,初始化为1;
        pb->func1();                         
                      //func1()不是虚函数,所以pb->func1()执行的是基类的func1函数,i= 10
                       //然后调用func2()函数 
                   //func2是虚函数,要往下派生类寻找,找到后执行派生类中的func2(),此时,i = 12;
        cout << pb->getValue() << endl; 
        delete pb; 
    } 

     

     

     

    展开全文
  • 文章目录一、单选题二、多选题三...2.以下关于false-path的说法正确的是:B    A、一般异步复位可以设置false-path    B、一般异步电路可以设置false-path    C、两个不同频率之间的接口一定可以设置为false-pat


    答案仅供参考

    一、单选题

    1.在SystemVerilog中,下列哪个数组在使用中会用到new操作:B
       A、多维数组
       B、动态数组
       C、联合数组
       D、压缩数组
    解析:动态数组在声明后,一般需要通过new[]操作来分配内存空间

    2.以下关于false-path的说法正确的是:B
       A、一般异步复位可以设置false-path
       B、一般异步电路可以设置false-path
       C、两个不同频率之间的接口一定可以设置为false-path
       D、一般模拟IP和系统的互联接口都可以设置为false-path
    解析:false-path 是在进行时序分析的时候,不需要工具进行分析的路径,一般就是异步的

    3.下面各条语句的执行顺序是什么?D

    initial begin
      $display("a",$time);
      #10  $display("b",$time);
      fork
         $display("c",$time);
         #50  $display("d",$time);
         #10  $display("e",$time);
         begin
           #10  $display("f",$time);
           #10  $display("g",$time);
         end
      join_any
      $display("h",$time);
      #80  $display("i",$time);
    end
    

       A、a、c、b、h、e、g、f、d、i
       B、a、c、b、h、e、g、f、d、i
       C、a、c、b、h、e、g、f、d、i
       D、a、b、c、h、e、f、g、d、i
    解析:考察fork…join_any语句块中的线程执行顺序

    4.语音频率为300~3400Hz,若对其采样后信号不失真,则最小的采样频率为:C
      A.7400Hz
      B.6200Hz
      C.6800Hz
      D.600Hz
    解析:取样定理:设取样信号的频率为fs,输入模拟信号的最高频率分量为fimax,则fs与fimax必须满足以下关系:fs>=2fimax

    二、多选题

    1.关于下列代码描述正确的是:AD

    always begin
      #5 clk=0;
      #10 clk=~clk;
    end
    

       A.周期为15
       B.clk= 0
       C.clk= 1
       D.占空比1/3的时钟

    2.关于队列pkt_q[$]的操作正确的是:BCD
       A.int pkt_q[$] = (1,2,3);
       B.pkt_q = { };
       C.pkt_q.push_front(3) ;
       D.pkt_q.delete();
    解析:A选项错误,队列直接进行初始化赋值操作需要用到{ }而非();B选项正确,队列的初始化常量赋值不需要“`”, q = { };语句清空队列;C选项在队列前添加元素3,D选项删除整个队列

    3.下列关于复位信号说法正确的是ABCD
       A.异步复位也需要同步到相应的时钟域,以便后续的STA分析
       B.异步复位对复位信号要求比较高,不能有毛刺
       C.异步复位不管时钟,只要复位信号满足条件,就完成复位
       D.同步复位在时钟沿采复位信号,完成复位动作

    4.找出4-state的数据类型AC
       A.time cur_tm;
       B.real c0;
       C.integer data_cnt;
       D.int pkt_cnt;
    解析: 2态只有1和0;4态是0,1,Z,X。2态数据类型不初始化,则默认是0;4态数据类型不初始化,则默认是X。不要用2态的数据类型去做ADC数据采集。在对4态数据类型做比较的时候,使用三个等号(a === b),而不两个等号(a == b)。
    4-state的数据类型包含有:wire、reg、logic、integer、time

    参考:https://www.cnblogs.com/yiwenbo/p/10103207.html

    5.以下观FIFO说法正确的是:
       A.外部可以直接操作FIFO的读写地址
       B.FIFO可以分为同步FIFO和异步FIFO
       C.FIFO是先进先出的存储器
       D.空信号是在写时钟域产生的,满信号是在读时钟域产生的
    解析:FIFO的读写地址属于内部信号,外部不可以直接进行操作;空信号是在读时钟域产生的,满信号是在写时钟域产生的

    三、问答题

    1.please use Verilog to implement the divided by seven circuit with duty cycle of 50%.

     module test#(parameter N=7)(//N分频
     input clk,
     input rst_n,
     output clk_div
     );
     
     reg sig_r ;//定义一个上升沿翻转的信号
     reg sig_f ;//定义一个下降沿翻转的信号
     reg [N-1:0]    cnt_r;//上升沿计数器
     reg [N-1:0]    cnt_f;//下降沿计数器
    
     wire clk_f ;
     assign clk_f = ~clk ;//用来触发下降沿计数器的时钟
                         //由于同时使用上升沿和下降沿触发器不好,因此我们为同一边沿,都使用上升沿触发
                         //只不过是将时钟进行反向
                         
     always @(posedge clk or negedge rst_n)begin//上升沿计数
         if(rst_n == 1'b0)begin
             sig_r    <= 0 ;
             cnt_r    <= 0 ;
         end else if( cnt_r == (N-1)/2 )begin
             sig_r    <= ~sig_r ;
             cnt_r    <= cnt_r + 1 ;
         end else if ( cnt_r == (N-1) )begin
             sig_r    <= ~sig_r ;
             cnt_r    <= 0 ;
         end else 
             cnt_r    <= cnt_r + 1 ;
     end                     
     
     always @(posedge clk_f or negedge rst_n)begin//下降沿计数
         if(rst_n == 1'b0)begin
             sig_f    <= 0 ;
             cnt_f    <= 0 ;
         end else if( cnt_f == (N-1)/2 )begin
             sig_f    <= ~sig_f ;
             cnt_f    <= cnt_f + 1 ;
         end else if ( cnt_f == (N-1) )begin
             sig_f    <= ~sig_f ;
             cnt_f    <= 0 ;
         end else 
             cnt_f    <= cnt_f + 1 ;
     end 
     
     assign clk_div = sig_f || sig_r ;
                         
    endmodule
    
    

    2.指出下列代码中的错误,并写出执行的结果

    program bad_test;
      initial begin、
        for(int  chan_id=0; chan_id<0; chan_id++)
            fork
              paket_process(chan_id) ;
            join_any
      end
    endprogram
    

    解析:在for循环中直接调用fork…join_any语句块,会造成出乎意料的打印结果,对于上述代码而言,for循环会先建立8个进程,然后等待for循环结束后,才执行8个fork进程,由于for循环执行完毕后,此时chan_id值为8,之后8个进程packet_process(chan_id);才开始执行,其执行结果如下:

    packet_process(8);
    packet_process(8);
    packet_process(8);
    packet_process(8);
    packet_process(8);
    packet_process(8);
    packet_process(8);
    packet_process(8);
    

    改正:在源代码的fork…join_any语句块基础上添加语句automatic int j=chan_id即可,如下所示:

            fork
              automatic int j=chan_id;
              paket_process(j) ;
            join_any
    

    打印执行结果如下所示:

    packet_process(0);
    packet_process(1);
    packet_process(2);
    packet_process(3);
    packet_process(4);
    packet_process(5);
    packet_process(6);
    packet_process(7);
    

    3.以下代码的覆盖率能否达到100%,为什吗?

    bit [2:0]  vlan_len;
    bit [3:0]  type_len;
    covergroup   cg;
      coverpoint  (vlan_len + type_len + 5'b0);
        {bins   len[] = {[0:23]};};
    endgroup
    

    解析:覆盖率不能达到100%,实际的最大覆盖率仅能达到23/24=95.83%。这是由于实际的覆盖单的取值范围:[0:22],(22=7+15),而bins的取值范围:[0:23],实际取值23是不能被覆盖的。
    修正:将bins的范围改为bins len[]={[0:22]};即可

    4.OOP的三大特性是什么,解释。
    解析:OOP的三大特性分别为:封装性、继承性、多态性
       封装性:就是将抽象得到的数据和行为相结合,形成一个有机的整体。即,将数据与数据操作的函数代码进行有机整合,形成类class,其中数据和函数都是类的成员。
       继承性:就是新的类从已有类那里得到已有的特征。从已有类那里得到新类的过程就是类的派生。类的继承与派生机制允许新的类在原有类的基础上进行修改和补充。原有的类称为基类或父类,新类称为派生类或子类。子类继承了父类所有的成员方法和属性,并且可以拥有自己特性。通过关键字extends实现继承解决了代码的重用问题。
       多态性:多态是在不同继承关系的类对象,去调用同一函数,产生了不同的行为,即一个子类的指针在以父类的类型传递时,表现出的行为依然是子类的行为。多态的实现需要满足两个条件:1.必须通过基类的指针或者引用调用虚函数;2.被调用的函数必须是虚函数,且派生类必须对基类的虚函数进行重写。

    5.build_phase和connect_phase分别是自底向上执行还是自顶向下执行,为什吗?
       解析:.build_phase自顶向下执行,这么做是为了建立足够的内存空间,以便后续的底层组件能够进行实例化,从而搭建起uvm-tree结构
       connect_phase自底向上执行,这么做是为了贴合数据的流动方向

    6.什么是亚稳态,产生原因?如何消除?
       解析:亚稳态是指触发器无法在某个规定时间段内达到一个可确认的状态。
       出现亚稳态的根本原因是由于触发器输入信号不满足触发器的建立时间和保持时间的时序要求。
       消除方法:打两拍(单bit)、格雷码、握手机制、异步FIFO。

    展开全文
  • 5、 下列关于栈的叙述中正确的是()。 A、 在栈中只能插入数据 B、在栈中只能删除数据 B、 栈是先进先出的线性表 D、栈是先进后出的线性表 我的答案:D 6、 下面不属于软件设计原则的是()。 A、 抽象 B、...
  • 动态声明一维数组数组大小未知时,需要动态声明一维数组,声明... 下列___是不正确的字符常量? A. ‘n’ B. ‘I’ C. “a” D. ‘\101’ 解析:答案选C,C选项是一个字符串常量,其包含字符’a’和空字符两个字符
  • C++错题归纳

    2021-01-15 19:54:16
    2、关于消息,下列说法中不正确的是( )。(1.0分) 答案:消息的发送者必须了解消息的接收者如何响应消息 3、存储以下数据,占用存储字节最多的是( )。(1.0分) 答案:0.0 4、对类中常量成员的初始化是通过构造函数中...
  • 关于索引设计和使用下列哪些说法是正确的:AD A .若查询条件中不包含索引最左列,则无法使用索引。 B .对于范围查询,只能利用索引最左列。 C .对于order by A或group by A语句,在A上建立索引,可以...
  • JAVA面试题最全集

    2010-03-13 13:09:10
    链表与散列表和数组的区别 19.堆和栈的区别 20.ejb的分类及区别 21.你对现在软件业以及国内软件业的看法 22.谈谈java多线程 23.谈谈文件加密技术 24.软件开发生命周期 25.路由协议种类及特点 26.java的awt和...
  • 10.5.2 数组的格式化输出 399 10.5.3 数组的格式化输入 400 10.6 打印机输出 400 10.7 小结 401 10.8 习题 401 第11章 结构化数据 403 11.1 数据结构:使用struct 403 11.1.1 定义结构类型和结构变量 405 ...
  • DBX260中文说明书

    2013-04-24 11:07:35
    忠告:要想正确使用RTA话筒,必须要按下RTA按钮,并且将接地/浮地开关置于接地位置。当后面板RTA按钮按下时,在XLR接口2和3脚上加上48V幻象电源。要维持幻象电源有正确接地回路,接地/浮地开关必须处在接地...
  • 数据结构(C++)有关练习题

    热门讨论 2008-01-02 11:27:18
    请编写一个函数将这个线性表原地逆置,即将数组的前n个原地址内容置换为(en-1,en-2,…,e3,e2,e1,e0)。 2、 针对带附加头结点的单链表,试编写下列函数: A. 定位函数Locate:在单链表中寻找第i个结点。若找到...
  • C++程序员面试宝典

    热门讨论 2013-04-01 13:36:19
    面试题88 数组指针与指针数组的区别 92 8.2 函数指针 93 面试题89 什么是函数指针?如何使用函数指针 93 面试题90 指针函数和函数指针的区别 95 8.3 this指针 96 面试题91 什么是this指针 96 面试题92 何时使用this...
  • C++复习资料之系列

    2008-12-30 21:35:45
    后,下列正确的语句是( b )。 (a) &pb = a; (b) pb = pa; (c) &pb = &pa; (d) *pb = *pa; 17.执行下面语句后,a和b值分别为( b )。 int a = 5,b = 3,t; int &ra = a; int &rb = b; t = ra;...
  • 1、编写程序,测试下列数组的定义方式是否正确 (1) main() { int n; scanf(“%d”,&n); int a[n]; …… } (2) main() { const int n=10; int a[n]; } (3) #include #define M 10 main() { int a[M]; ...
  • 4.3.4 多维数组的动态分配 176 4.4 使用引用 177 4.4.1 引用的概念 177 4.4.2 声明并初始化引用 177 4.5 C++/CLI编程 178 4.5.1 跟踪句柄 178 4.5.2 CLR数组 180 4.5.3 字符串 195 4.5.4 跟踪引用...
  • 新手学习C++入门资料

    2008-12-28 23:58:50
    尽管这样用法是正确的,但大多数C和C++编译器都会给出一个警告,说参数y在程序中没有被用到。为了避免这样警告,C++允许声明一个无名形参,以告诉编译器存在该参数,且调用者需要为其传递一个实际参数,但是...
  • 使用二分法查找线性表必须满足用顺序存储结构和线性表是有序表两个条件。 “有序”是特指元素按非递减排列,即从小到大排列,但允许相邻元素相等。下一节排序中,有序含义也是如此。 对于长度为n有序线性表...
  • 因为GetMemory返回的是指向“栈内存”的指针,该指针的地址不是 NULL,但其原现的内容已经被清除,新内容不可知。 void GetMemory2(char **p, int num) { *p = (char *)malloc(num); } void Test(void) { char *...
  • (9) 下列叙述中正确的是(C) A.数据库是一个独立的系统,不需要操作系统的支持 B.数据库设计是指设计数据库管理系统C.数据库技术的根本目标是要解决数据共享的问题 D.数据库系统中,数据的物理结构必须与逻辑结构一致...
  • 数组的下标不要发生“多1”或者“少1”操作。 3.对排版的规定 ●缩进要对齐; ●长行拆分; ●二元操作符的前后应当加空格,包括如下操作符: 赋值操作符、比较操作符、算术操作符、逻辑操作符、位域...
  • 数组的下标不要发生“多1”或者“少1”操作。 3.对排版的规定 ●缩进要对齐; ●长行拆分; ●二元操作符的前后应当加空格,包括如下操作符: 赋值操作符、比较操作符、算术操作符、逻辑操作符、位域操作符,如...
  • 《数据结构 1800题》

    热门讨论 2012-12-27 16:52:03
    15. 下列数据中,(C )是非线性数据结构。【北京理工大学 2001 六、1(2分)】 A.栈 B. 队列 C. 完全二叉树 D. 堆 16.连续存储设计时,存储单元地址(A )。【中山大学 1999 一、1(1分)】 A.一定连续 B....
  • 设定字符串为“张三,你好,我是李四” 产生张三的密钥对(keyPairZhang) 张三生成公钥(publicKeyZhang)并发送给李四,这里发送的是公钥的数组字节 通过网络或磁盘等方式,把公钥编码传送给李四,李四接收到张三编码后...
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
     张三生成公钥(publicKeyZhang)并发送给李四,这里发送的是公钥的数组字节  通过网络或磁盘等方式,把公钥编码传送给李四,李四接收到张三编码后的公钥,将其解码,李四用张三的公钥加密信息,并发送给李四,张三用...

空空如也

空空如也

1 2
收藏数 37
精华内容 14
关键字:

下列正确使用动态数组的是