我需要一种方法来检查字符串是否只包含字母字符.由于我在程序中需要多次使用该功能,因此我认为将它放入函数是个好主意.

这是我的实现：

int sisalpha(const char *s) {
    int result = 1;

    while (s++ != '\0') {
        result = isalpha(*s); // uses isalpha of <ctype.h>

        if (result == 0) {
            return result;
        }
    }

    return result;
}

我能在这里改进什么？传递某种大小以避免缓冲区溢出并允许检查“子串”是否有益？

使用 strspn.

设置要检查的字符集,大写和小写字母.如果strspn返回的值与strlen相同,则它全部为字母.

首先,有什么区别：

(1) const char*(2) char const*(3) const char const*

我相当肯定我完全理解了这一点,但是我想让某人给我一个句子,具体来说就是粘在我的脑海里.这是其中一件事,我很好,直到有人把我当场,然后它变得模糊！

另外,编译器如何存储string-literall？这不是家庭作业,我只是在C上刷新面试,以防任何人关心.

1和2是等价的,并指定一个指向const char的指针的类型.指针本身不是const. 3是无效的,因为它重复“const”.就像说const const int一样.这个顺序是不相关的,所以也是说int const int.

在C99中,这样重复const就是有效的.但在C中,你不能重复.

Also,how are string-literalls stored by the compiler?

它们以未指定的方式存储.但编译器可以将它们存储在程序的只读部分.所以你不能写字符串文字.您保证在整个程序生命周期内保持分配(换句话说,它们具有静态存储持续时间).

This isn’t homework,I’m just brushing up on C for interviews in case anyone cares.

你应该意识到C和C之间的细微差别.在C99中,如上所述,const const int是允许的.在C89和C中是禁止的.在C中,您可以引入一个冗余的const,如果应用于本身是const的typedef：

typedef int const cint;cint const a = 0; // this const is redundant!

模板参数也是如此.

我想要实现的是具有适用于字符串文字和std :: string的函数的重载,但是为const char *参数产生编译时错误.以下代码几乎完全符合我的要求：

#include <iostream>
#include <string>

void foo(const char *& str) = delete;

void foo(const std::string& str) {
    std::cout << "In overload for const std::string&     : " << str << std::endl;
}

template<size_t N>
void foo(const char (& str)[N]) {
    std::cout << "In overload for array with " << N << " elements : " << str << std::endl;
}   

int main() {
    const char* ptr = "ptr to const";
    const char* const c_ptr = "const ptr to const";
    const char arr[] = "const array";
    std::string cppStr = "cpp string";

    foo("String literal");
    //foo(ptr); //<- compile time error
    foo(c_ptr); //<- this should produce an error
    foo(arr);   //<- this ideally should also produce an error
    foo(cppStr);
}

我不高兴,它编译char数组变量,但我认为如果我想接受字符串文字(如果有,请告诉我)没有办法解决它

但是我想避免的是,std :: string重载接受const char * const变量.不幸的是,我不能只声明一个带有const char * const&的删除重载.参数,因为它也匹配字符串文字.

任何想法,我如何使foo(c_ptr)产生编译时错误而不影响其他重载？

此代码执行所需操作(除了数组 – 文字是数组,因此您无法将它们分开)

#include <cstddef>
#include <string>

template <class T>
void foo(const T* const & str) = delete;

void foo(const std::string& str);

template<std::size_t N>
void foo(const char (& str)[N]);

int main() {
    const char* ptr = "ptr to const";
    const char* const c_ptr = "const ptr to const";
    const char arr[] = "const array";
    std::string cppStr = "cpp string";

    foo("String literal");
    //foo(ptr); //<- compile time error
    // foo(c_ptr); //<- this should produce an error
    foo(arr);   //<- this ideally should also produce an error
    foo(cppStr);
}

我有 this code的工作原理：

#define MAX_ParaM_NAME_LEN 32

const char* GetName()
{
    return "Test text";
}

int main()
{
    char name[MAX_ParaM_NAME_LEN];
    strcpy(name,GetName());    

    cout << "result: " << name << endl;
}

如果我想将结果存储到一个char *(因为框架中的一些功能我只使用char *作为输入),而不使用strcpy(为了实用性和可读性的代码,也学习),怎么可能我做？保持const,这很好：

const char* name;
name = GetName();

但我仍然有const.

尝试使用char *：

char* name;
name = GetName();

我从“const char *”到“char *”的转换无效.这种转换最好的习惯是什么？

返回“测试文本”;返回一个指向只读字符串文字的指针.

如果你使用一个将char *作为输入的函数,并且你有一个const char *(如只读字符串文字),那么你应该提供一个从该const char开始的字符串的深层副本*这样的功能.

否则如果函数尝试修改只读字符串,则在运行时会冒冒险行为.

你目前拥有的是足够的假设你不能使用std :: string. (如果您可以使用std :: string,并且所有框架函数都使用const char *输入,那么我建议您重构代码以使用std :: string,并将c_str()方法的输出传递给那个字符串类到你的框架函数.)

最后,如果你的一些框架函数需要一个char *,那么你可以随时建立一个小的适配器类：

class Adapter
{
public:
    Adapter(const& Adapter) = delete; /*don't try to copy me please*/
    Adapter& operator=(const Adapter& ) = delete; /*don't try to copy me please*/
    Adapter(const char* s) : m_s(::strdup(s))
    {
    }
    ~Adapter() /*free memory on destruction*/
    {
        ::free(m_s); /*use free to release strdup memory*/
    }
    operator char*() /*implicit cast to char* */
    {
        return m_s;
    }
private:
    char* m_s;
};

然后对于函数void foo(char * c),可以调用foo(Adapter(“Hello”/ *或任何const char * * /));并且foo可以像嵌入匿名临时的char *一样喜欢它！你甚至可以加强这个类来构造一个char *,在这种情况下,只有一个浅的拷贝的指针被占用(并且析构函数不会删除内存).

我正在尝试在C中创建简单的应用程序.此应用程序必须从文件中读取并显示数据.我写的功能：

std::vector <AndroidApplication> AndroidApplication::getAllApp(){
    std::vector<AndroidApplication> allApp;
    std::fstream f;

    f.open("freeApps.txt");
    std::string line;
    if(f.is_open()){
        while(getline(f,line)) {
            std::string myLine = "";
            char * line2 = line.c_str();
            myLine = strtok(line2,"\t");

            AndroidApplication * tmpApp = new AndroidApplication(myLine[1],myLine[2],myLine[4]);
            tmpApp->Developer = myLine[0];
            tmpApp->Pop = myLine[3];
            tmpApp->Type = myLine[5];
            allApp->pushBack(tmpApp);
        }
    }
    return allApp;
}

它引发了我的错误：

myLine = strtok(line2,"\t");

一个错误：

cannot convert from ‘const char *’ to ‘char *’

你能告诉我怎么处理它？

要使用strtok,您需要一个可写的字符串副本. c_str()返回一个只读指针.