关于数字ic设计/验证, 你要了解的基础C++编程

1. 写C语言来检测小印第安序或大印第安序。假设32位，有无符号数1。

小印地安序（little Endian）：高位放在低地址——(MSB) 000==1== (LSB)
大印地安序（big Endian） ：高位放在高地址——(MSB) 100==0==(LSB)

#include<stdio.h>
int main()
{
  unsigned int i=1;
  char*c=(char*)&i; //&i是i的地址，表示i在内存中的位置; (char*)&i是将&i转型:由int的指针到char的指针
  if(*c)
    printf("Little Endian \n");//高亮处判定
  else
    printf("Big Endian \n");
    return 0;
}

2. 以下代码的输出结果是

(1)求b,c的值

a = 10;
b = a++;
c = ++a;

答： b=10; c=12.

(2)求y的值

int main() {
int x=4;
float y = * (float *) &x;
return 0;
}

浮点数在内存中的存储形式
答：结果非常小,约等于0.
float类型有1个符号位（S），有8个指数位（E），和23个有效数字位（1<=M<2）
整数4存入浮点型时，（00000000 0.0000000 00000000 00000100），等于
1.00 x 2^-21 x 2^-126

(3)求打印结果

#include<stdio.h>
int main()
{
int i=0;
for(i=0;i<20;i++)
{
switch(i) {
case 0:i+=5;
case 1:i+=2;
case 5:i+=5;
default: i+=4;
break;
}
printf("%d\n",i);
}return 0;
}

答：
首先，i=0; i=i+5=5; i=i+2=7; i=i+5=12; i=i+4=16 从case0一直运行到break;
然后，i=i++=17; i=i+4=21; 运行了default后break;
所以会打印16与21.
C语言中switch…case语句中，break不可或缺，没break将会变成串行执行语句。

(4) 假设为64 bits，求输出结果

#include <stdio.h>
int main()
{
int x = 10000;
double y = 56;
int *p = &x;
double *q = &y;
printf("p and q are %d and %d", sizeof(p), sizeof(q));
return 0;
}

答: p和q为指针，指向地址。因为是64位(8 Bytes)机器，所以sizeof都为8.

3. C语言递归函数实现——n的阶乘（n!）

int factorial(int x)
{
if ((x==0) || (x==1))
   return 1;
else
   return (x*factorial(x-1));
}

4. C语言递归函数实现——斐波那契数列

斐波那契数列，又称为“兔子数列”：1、1、2、3、5、8、13、21、34、……
(前两个数之和等于第三个)

int fibonacci (int num)
{
if((num==1) || (num==2))
   return 1;
else
  return (fibonacci(num-1) + ()fibonacci(num-2))
}

5. 什么是链表(Linked List)? 什么时候用链表？

链表是一种数据结构。链表节点(node)包括数据+顺序。
链表一般都在对数据的多少(volume)未知的情况下使用的。插入和删除时不需移动其他元素, 只需改变指针。有利于数据的增加，删除，编辑。

6. 运用以下变量和声明，完成C语言函数编写。

struct node; // node结构体
typedef struct node NODE; //将node定义为NODE
typedef int Element; //定义Element
typedef NODE *LINK; // 用Link代替NODE*

struct node {      //node结构体，有一个数据和一个指针
Element elem;
LINK next;
};

typedef struct // 定义ListHead结构体
{
int size;
LINK start;
} ListHead;

6.1 单向链表的建立。

C语言——单向链表的介绍

ListHead createList(){
  ListHead h;
  h.size = 0;
  h.start = NULL;
  return h;
  }

6.2 在单向链表开头插入元素。

关于单向链表操作的C语言编程

ListHead InsertElementAtHead(Element e, ListHead h) {
  LINK nl=(LINK) malloc(sizeof(NODE)); //malloc函数：分配长度为num_bytes字节的内存块
  nl->elem = e;        //为新节点分配空间并将数据存储到节点的数据部分
  nl->next = h.start;  //使新节点的链接部分指向链表的原有的第一个节点
  h.start = nl;        //最后，需要将新节点作为链表的第一个节点
  h.size++;
return h;
}

6.3 在单向链表末端插入一个元素。

ListHead InsertElementAtTail(Element e, ListHead h) {LINK temp;
LINK nl;
nl=(LINK) malloc (sizeof(NODE));
nl->elem=e;
nl->next=NULL;
if(h.start==NULL)  //情况1，插入空列表
h.start=nl;
else
{
temp=h.start;
while(temp->next!=NULL)  //情况2：插入非空列表
temp=temp->next;
temp->next=nl;
}
h.size++;
return h;
}

6.4 在单向链表pos位置前插入一个元素。

ListHead InsertAtPos(Element e, ListHead h, int pos) {
LINK temp;
LINK nl;                 //插入n1
nl=(LINK)malloc(sizeof(NODE));
nl->elem=e;
int count=0;
if(pos>h.size){
    printf("Error: Wrong position \n");
    return h; }
if(pos==0)                 //插入在开头
{
    nl->next=h.start;
    h.start=nl;
}
else 
{
   for (temp = h.start; count<(pos-2); temp = temp->next, count++) ; 
        nl->next=temp->next;         //将n1移动到pos前
        temp->next=nl;
}
h.size++;
return h;
}

6.5 在单向链表中删除一个元素。

ListHead DeleteElement(Element e, ListHead h) {
LINK cur, prev;         //cur指当前元素所在位；prev前一个元素所在位置
cur=h.start;
if(cur==NULL)
 { printf ("Empty List \n");
   return h; 
 } 
while(cur!=NULL)
{
 if(cur->elem==e)
  {
  if(cur==h.start)        //若在开头，删除开头元素
    h.start=cur->next;
  else
    prev->next=cur->next; //被删除元素前一个(prev)的next等于被删除元素的next
    free(cur);            //释放cur所在内存
    h.size--;
  break;
  }
 prev=cur;              //前一个元素变成了当前元素
 cur=cur->next;         //原本的当前元素变成下一个元素
}
return h;
}

Reference: 《Cracking Digital VLSI Verification Interview: Interview Success》
对该书进行了整理和加了一些自己的理解，如有错误，欢迎指正。