c语⾔言语法,常⽤用数据结构

• 什么是指针 type *p ;
  一类数据类型,用来存储内存单元的编号指针 不完全等于 地址,有类型的标识很多类型的指针,指向数据、指向方法、void 型不同的编译环境,sizeof 可能不同

• 指针和数组有什么区别

char *p = “hello”;
 char a[] = “hello”;

• 变量名代表的意义:
  p:只是一个指向某个内存块的一个变量
  数组名:
  1、sizeof 的时候代表整个数组
  2、代表数组首个元素的首地址,在值上等于数组的地址对变量名的修改:数组相当于 chat * const p; 常型指针对代表数据的操作:
  修改、复制、sizeof、予以区分,参考《指针和数组的区别》
• 写出标准宏MIN,这个宏输⼊入两个参数并返回较⼩小的⼀一个

#define MIN(a,b) ((a)>(b)?(b):(a))
延伸:
#define RADIANS_TO_DEGREES(radians) ((radians) * (180.0 / M_PI))
#define DEGREES_TO_RADIANS(angle) ((angle) / 180.0 * M_PI)

• 需要了解下 BuildSetting 的 DEBUG_MODE如何引⽤用⼀一个已经定义过的全局变量
• 多个.m文件定义同名的引起link 错误int global_Value = 1;extern int global_Value;
• 编译原理:.h、.m 怎么编译,怎么链接,怎么打包static 全局变量和普通变量的区别、局部变量呢?函数
  Static变量 限定了作用域的全局变量C语言中的static函数是限定作用域的全局函数C++中的 static 函数是相对于成员函数而言,调用主体是类
  降低模块间的耦合度静态全局变量的作用域局限于一个源文件内,可以避免在其它源文件中引起已定义错误
• 队列和栈的区别
  先进先出 先进后出
• 堆和栈
  堆内存:自己申请开辟的内存空间栈内存:系统自动管理的内存空间比如:方法块内部的变量,当方法执行结束后,栈内存自动回收

-(void)methods
{int i = 4;//栈内存int* ptr = &i;//栈内存ptr = malloc(100);//堆内存,得到的是否是连续可操作的内存?
}

递归 的栈内存 一直没有释放,导致性能低下

• 声明⼀一个有10个指针的数组,该指针指向⼀一个函数,该函数有⼀一个整形参数并返回⼀一个整型数

• 函数
  int func (int)
  函数指针int (pFunc)(int)
  指针数组 :一个包含10个int型指针的指针数组int p[10];
  数组指针 :指向一个包含10个int型值的数组的指针int (p)[10];
  结果:有10个指向函数的指针的指针数组int (*arrFunc[10])(int)
  交换两个变量的值,不使⽤用第三个变量

a = a + b; 
b = a – b; 
a = a – b;
a = a ^ b;
 b = a ^ b; 
a = a ^ b;
计算sizeof的值
void *p = malloc(100);
sizeof(p)= ?;
void Func(char str[100]){
sizeof(str) = ?;}

• static 关键字的作用?
• )第一个作用:隐藏。 当我们同时编译多个文件时,所有未加static前缀
  的全局变量和函数都具有全局可见性。
• )static的第二个作用是保持变量内容的持久。存储在静态数据区的变量
  会在程序刚开始运行时就完成初始化,也是唯一的一次初始化。共有两种变量存储在静态存储区:全局变量和static变量,只不过和全局变量比起来,static可以控制变量的可见范围,说到底static还是用来隐藏的。
• )static的第三个作用是默认初始化为0。其实全局变量也具备这一属性,因为全局变量也存储在静态数据区。在静态数据区,内存中所有的字节默认值都是0x00,某些时候这一特点可以减少程序员的工作量。
• 线程与进程的区别和联系?
  一个进程可以有一个或者多个线程组成,进程和程序并不是一一对应的,一个程序执行在不同的数据集上就成为不同的进程,可以用进程控制块来唯一地标识每个进程。而这一点正是程序无法做到的,由于程序没有和数据产生直接的联系,既使是执行不同的数据的程序,他们的指令的集合依然是一样的,所以无法唯一地标识出这些运行于不同数据集上的程序。一般来说,一个进程肯定有一个与之对应的程序,而且只有一个。而一个程序有可能没有与之对应的进程(因为它没有执行),也有可能有多个进程与之对应(运行在几个不同的数据集上)。
• 堆和栈的区别?
• )、栈区(stack)― 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。
• )、堆区(heap) ― 一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 。
• C 语言如何判断两个单向无环链表是否相交?只需判断两个链表的尾节点地址是否相同,相同则相交,不同则不相交
• 程序在内存中运行时,内存分几个区,各自用途?
• 栈 --有编译器自动分配释放
• 堆 -- 一般由程序员分配释放,若程序员不释放,程序结束时 可能由 OS 回收
• 全局区(静态区) -- 全局变量和静态变量的存储是放在一块 的,初始化的全局变量和静态变量在一块区域,未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束释放。
• 另外还有一个专门放常量的地方。程序结束释放。
• 引用与指针有什么区别
• 指针指向一块内存,它的内容是所指内存的地址;引用是某块内存的别名
• 指针是一个实体,而引用仅是个别名;
• 引用使用时无需解引用(*),指针需要解引用;
• 引用只能在定义时被初始化一次,之后不可变;指针可变;
• 引用没有 const,指针有 const;
• 引用不能为空,指针可以为空;
• “sizeof 引用”得到的是所指向的变量(对象)的大小,而“sizeof
• 指针”得到的是指针本身(所指向的变量或对象的地址)的大小;
• 指针和引用的自增(++)运算意义不一样;
• 从内存分配上看:程序为指针变量分配内存区域,而引用不需要分配
  内存区域。
• 编程:
• 请问运行完Test函数后,会有什么样的结果?

  (1)void GetMemory(char *p){
 p = (char *)malloc(100);
}
void Test(void){
 char *str = NULL; 
GetMemory(str); 
strcpy(str, "hello world"); 
printf(str);
}

运行Test函数的结果是程序崩溃。因为GetMemory并不能传递动态内存,Test函数中的 str一直都是 NULL。strcpy(str, "hello world");将使程序崩溃。

(2)char *GetMemory(void){
 char p[] = "hello world";
return p;
}
void Test(void){
 char *str = NULL; 
str = GetMemory(); 
printf(str);
}

运行Test函数的结果可能是乱码。因为GetMemory返回的是指向“栈内存”的指针,该指针的地址不是 NULL,但其原现的内容已经被清除,新内容不可知。

(3)void GetMemory2(char **p, int num){
 *p = (char *)malloc(num);
}
void Test(void){
 char *str = NULL; 
GetMemory(&str, 100); 
strcpy(str, "hello"); printf(str);
}

运行Test函数的结果是:(1)能够输出hello(2)内存泄漏

(4)void Test(void){
char *str = (char *) malloc(100);
strcpy(str, “hello”);
free(str);
if(str != NULL){
strcpy(str, “world”);
 printf(str); 
    }
}

运行Test函数的结果是:篡改动态内存区的内容,后果难以预料,非常危险。因为free(str);之后,str成为野指针,if(str != NULL)语句不起作用。

• .编写strcpy函数已知strcpy函数的原型是
  (1).char *strcpy(char *strDest, const char *strSrc);
  其中strDest是目的字符串,strSrc是源字符串。(1)不调用C++/C的字符串库函数,请编写函数

 strcpychar *strcpy(char *strDest, const char *strSrc);
strcpychar *strcpy(char *strDest, const char *strSrc){
assert((strDest!=NULL) && (strSrc !=NULL));
char *address = strDest;
while( (*strDest++ = * strSrc++) != ‘\0’ )
 NULL ; 
return address ;
}

(2)strcpy能把strSrc的内容复制到strDest,为什么还要char * 类型的返回值?答:为了实现链式表达式。

例如 int length = strlen( strcpy( strDest, “helloworld”) );

4.完成下面函数以实现使用辗转相除法获取两个数(假设两个数都大于0)的最大公约数example: gcd(20,5 ) = 5. gcd(3,10 ) = 1. gcd(1620,1280 )= 20.

unsigned int gcd(unsigned int a,unsigned int b){
if (a < b) {
        gcd(b, a);
    }
    return b==0?a:gcd(b, a % b);
}

• 关键字 const 有什么含义?const 修饰谁,谁在整个程序运行过程中不能变
• 下方代码输出结果为可以看出指针加1和指针的地址加1的区别

#include <stdio.h>
int main(int argc, const char * argv[]) {
    int a[5] = {1, 2, 3, 4, 5};
    int *ptr = (int *)(&a+1);
    printf("*(a+1) = %d \n*(ptr-1) = %d\n", *(a+1), *(ptr-1));
    // 注意 a[2] 2[a]输出的结果是一样的，因为a[2] = *(a + 2)而 2[a] = *(2 + a)
    printf("a[2] = %d\n2[a] = %d",a[2],2[a]);
    return 0;
*(a+1) = 2 
*(ptr-1) = 5
a[2] = 3
2[a] = 3
}

• 实现冒泡排序

void swap_sort(int *p, int n) {
 int i ,j;
 int tmp; 
for(i=0; i<n-1; i++) {
 for(j=0; j<n-1-i; j++) { 
if(p[j]>p[j+1]) {
 tmp=p[j]; 
p[j]=p[j+1]; 
p[j+1]=tmp;
}
}
}
}