某外企c语言笔试题。。求指导

1、作为开发团队的一员，你需要实现一些库函数提供给其他人使用。假设你实现的一个
函数原型如下：
int DoSomeThing(char* pParam)
{
...
}

2、下面的代码有什么问题？
char *_strdup( const char *strSource )
{
static char str[MAX_STR_LEN];
strcpy(str, strSource);
return str;
}

3、实现一个函数：取出一个全路径文件名中的全路径。
/* [in]  pszFullPath 全路径文件名
   [out] pszPathName 接收全路径的缓冲区
   [out] nCount   缓冲区大小
*/
int ExtractFilePath(char* pszFullPath, char* pszPathName, int nCount)
{
...
}

26 个解决方案

#1

static char str[MAX_STR_LEN];应改为char str[MAX_STR_LEN];]

#2

在strcpy(str, strSource)之前，应该先
int n = strlen（strSource）；
if(n < MAX_STR_LEN)
strcpy(str, strSource);

#3

#4

3. 从右向左搜索第一个 '\' 字符

#5

第二题的目的是考“缓冲区溢出”吧？

#6

第二个问题：
1.数组str[MAX_STR_LEN]在函数返回后就不存在了，任何对此内存区域内的操作都是危险的。
2.除此之外，strlen(strSource)+1>MAX_STR_LEN，就会出现overflow的问题，很危险。

#7

第1个：改为int DoSomeThing(const char* pParam)
第2个：可能缓冲区溢出，确保输入字符串末尾包含'\0'是函数使用者的事情，不是这个函数的责任，
第3个：从右向左搜索第一个 '\' 字符

#8

第二个问题：
0.用static是必须的，否则就会出现
    houdy(致力于图像/图形领域，成为有思想的程序员) ( ) 回复的第一点
1.char *_strdup( const char *strSource )
{
static char str[MAX_STR_LEN];
//strcpy(str, strSource);      //上面已有说明缓冲区溢出问题
                              //因此将此句改为：
      strncpy(str, strSource, MAX_STR_LEN);
return str;
2.提示调用者接收该函数传出的指针后不可free or delete.
  比如调用者这样调用肯定出错
        const char *pSrc = "....";
        char *p = _strdup( pSrc );
        //use p
        free(p);//肯定错
        // or delete p; //肯定错
}

#9

第二个问题：
3.提示调用者传入该函数的字符指针的长度不可大于MAX_STR_LEN-1

#10

第2个：（1）在调用strcpy之前首先要测试strSource是否为NULL，如果为NULL，那么调用strcpy或者strlen时会core dump。
（2）我觉得最好用动态内存分配，用静态局部变量的话，一，浪费空间，就算strSource只有一个字符，也要占用MAX_STR_LEN个字节。二，在第二次调用*_strdup时，会覆盖掉第一次调用的值。

#11

同意： huiguo309(langzi.com）的

#12

关注

#13

第二道问题是不是返回了一个局部指针，这样是不是会抱错？（和华为的一道笔试差不多）．

#14

quote:
1.数组str[MAX_STR_LEN]在函数返回后就不存在了，任何对此内存区域内的操作都是危险的。

???
static 不是定义在程序的静态数据区吗?相当于全局变量,怎么会不存在了呢???
static 的目的之一(改变存储类型)就是为了在两次函数调用之间保持一个不变值

quote:
第1个：改为int DoSomeThing(const char* pParam)

也可用引用,int DoSomeThing(const char& pParam), 用户调用语法更直观,并不损效率

#15

huiguo309(langzi.com）说得对！

#16

学习 UP

#17

#18

上面的朋友说的很有道理，题2主要考虑溢出和地址返回的问题！

#19

为何数组str[MAX_STR_LEN]在函数返回后就不存在了请教一下

#20

知道了
局部静态变量只在定义它的函数中有效

#21

const在这有什么用，谁能讲讲？：）

#22

xxxsunzk(大哥) ( ) 信誉：100  2004-11-19 10:19:00  得分: 0

   知道了
局部静态变量只在定义它的函数中有效



－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
static局部变量是可以把指针返回的！
局部静态变量所谓的局部只是说这个变量本身也就是句柄是局部的，
其指针的值是可以返回的。

而且最重要的一点：只有static的这种数组才能返回，因为，static数组在不是在函数调用堆栈中的，所以不会随着函数的返回而被释放(pop)掉，
那个_strdup函数主要问题是：线程不安全和没有检查长度！
如果要线程安全必须：
char * str=malloc(MAX_STR_LEN*sizeof(char));
.....
这样str的内存是分配在heap（堆）上，函数返回不会被释放！

#23

同意神经病的说法,也许我们换种说法更好一点:
char *_strdup( const char *strSource )
{
static char str[MAX_STR_LEN];
strcpy(str, strSource);
return str;
}
上边的代码问题有二:
1.str的缓冲区溢出
2.str是静态成员
静态成员带来的问题是:
它是本进程内唯一的,
它的生存周期是全局的,但是只有局部可见
在以上的代码中
static char str[MAX_STR_LEN];只在初次_strdup时被初始化
以后每次执行,其实是执行的:
char *_strdup( const char *strSource )
{
strcpy(str, strSource);
return str;
}
也就是说,不管是本进程的哪个线程调用这个函数,
都是对同一个内存地址在进行存取

以下的代码输出是什么?,为什么会这样?

#define MAX_STR_LEN 100

char *_strdup( const char *strSource )
{
static char str[MAX_STR_LEN];
strcpy(str, strSource);
return str;
}

#include <stdio.h>

int main(void)
{
    char *hl;
    char *wld;
    hl = _strdup("hello");
    wld = _strdup(",world");

    printf("%s%s",hl,wld);

    return 0;
}

人家只问你上边的代码会有什么问题,并没有让你改正

#24

2、下面的代码有什么问题？
char *_strdup( const char *strSource )
{
static char str[MAX_STR_LEN];
strcpy(str, strSource);
return str;
}

这是个sb问题

#25

这个 strdup 根本就是错误的。
char * strdup(char *s)
{
char *__old=(s);
int __len = strlen(s);
char*__new=(char *)malloc(__len+1);
__new[__len]='\0';
memcpy(__new,__old,__len);
return __new;
}

#26

#define MAX_STR_LEN 100

#include <iostream>

#include <stdio.h>

//using namespace std;

char *_strdup(const char *s )
{
/* static char str[MAX_STR_LEN];
strcpy(str, strSource);
return str;*/
const char *_old = s;
int _len = strlen(s);
char*_new=(char *)malloc(_len+1);
_new[_len]='\0';
memcpy(_new,_old,_len);
return _new;
}

int main(void)
{
    char *hl;
    char *wld;
    hl = _strdup("hello");
    wld = _strdup(",world");

    printf("%s%s\n",hl,wld);

    return 0;
}

#1