相关疑难解决方法(0)

在C++中转换int为等效的最简单方法是什么？string我知道两种方法.有没有更简单的方法？

(1)

int a = 10;
char *intStr = itoa(a);
string str = string(intStr);

(2)

int a = 10;
stringstream ss;
ss << a;
string str = ss.str();

我想知道是否存在itoa()将整数转换为字符串的替代方法,因为当我在visual Studio中运行它时会收到警告,当我尝试在Linux下构建程序时,我收到编译错误.

Windows XP SP3.Core 2 Duo 2.0 GHz.我发现boost :: lexical_cast性能非常慢.想找出加速代码的方法.在visual c ++ 2008上使用/ O2优化并与java 1.6和python 2.6.2进行比较我看到以下结果.

整数铸造:

c++: 
std::string s ;
for(int i = 0; i < 10000000; ++i)
{
    s = boost::lexical_cast<string>(i);
}

java:
String s = new String();
for(int i = 0; i < 10000000; ++i)
{
    s = new Integer(i).toString();
}

python:
for i in xrange(1,10000000):
    s = str(i)

我看到的时间是

c ++:6700毫秒

java:1178毫秒

python:6702毫秒

c ++和python一样慢,比java快6倍.

双铸:

c++:
std::string s ;
for(int i = 0; i < 10000000; …

我正在尝试编写一个执行基本转换的C++程序.

我想将十进制数转换为2到20之间的所有其他整数基数.

对于基本转换,是否有一种高效且易于实现的算法？

目前,我的代码就是这样:

void ReadFile(double Cst[][1000], char* FileName, int height)

FILE* ifp;
double value;
int nRead = 0;
int mRead = 0;

//open the file, check if successful
ifp = fopen( FileName, "r" );
if (ifp==NULL){
    ...
}


for (nRead = 0; nRead < height; nRead++){
    for (mRead = 0; mRead < 1000; mRead++){
        fscanf(ifp, "%le",&value);
        Cst[nRead][mRead]=value;
    }
}

fclose(ifp);

我可以改变什么来使它尽可能快？

我从来没有太多使用C++ I/O流,并且总是选择我所知道的.即printf功能.

我知道使用I/O流有一些好处,但我正在寻找stackoverflow社区的一些技巧来帮助我(或说服我)切换.因为我仍然更喜欢printf,我认为printf样式更容易阅读和更快速的输入.

即使我仍然继续使用printf,我仍然希望熟悉它.

编辑.有趣的是,谷歌C++编码风格禁止使用除日志记录之外的流.请参阅:http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml

流

仅使用流进行日志记录.定义:Streams是printf()和scanf()的替代品.

优点:使用流,您不需要知道要打印的对象的类型.格式字符串与参数列表不匹配时没有问题.(虽然使用gcc,你也没有printf的那个问题.)Streams有自动构造函数和析构函数来打开和关闭相关文件.

缺点:Streams使得难以执行pread()等功能.一些格式化(特别是常见格式字符串成语%.*s)即使不是不可能有效地使用流而不使用类似printf的黑客也是困难的.Streams不支持运算符重新排序(%1s指令),这有助于国际化.

决策:除了日志记录界面要求之外,不要使用流.请改用类似printf的例程.

使用流有各种各样的利弊,但在这种情况下,与许多其他情况一样,一致性胜过辩论.不要在代码中使用流.

扩展讨论

关于这个问题一直存在争议,因此这更深入地解释了推理.回想一下唯一的方法指导原则:我们希望确保每当我们执行某种类型的I/O时,代码在所有这些地方看起来都是一样的.因此,我们不希望允许用户在使用流或使用printf和读/写/等之间做出决定.相反,我们应该选择其中一个.我们为日志记录做了例外,因为它是一个非常专业的应用程序,并且由于历史原因.

流的支持者认为流是两者中明显的选择,但问题实际上并不那么清楚.他们指出,对于流的每个优点,都存在同样的缺点.最大的优点是您不需要知道要打印的对象的类型.这是一个公平的观点.但是,有一个缺点:你可以轻松使用错误的类型,编译器不会警告你.在不知道何时使用流的情况下很容易犯这种错误.

cout << this;  // Prints the address 
cout << *this;  // Prints the contents 

Run Code Online (Sandbox Code Playgroud)

编译器不会生成错误,因为<<已经过载.出于这个原因,我们不鼓励超载.

有人说printf格式是丑陋的,难以阅读,但流通常不会更好.考虑以下两个片段,两者都有相同的拼写错误.哪个更容易发现？

cerr << "Error connecting to '" << foo->bar()->hostname.first
     << ":" << foo->bar()->hostname.second << ": " << strerror(errno);
fprintf(stderr, "Error connecting to '%s:%u: %s",
      foo->bar()->hostname.first, foo->bar()->hostname.second,
      strerror(errno)); 

Run Code Online (Sandbox Code Playgroud)

对于您可能提出的任何问题,等等等等.(你可以争辩说,"使用合适的包装器会更好",但如果对于一个方案是真的,对另一个方案是否也是如此？另外,请记住,目标是使语言更小,而不是添加更多有人必须学习的机器.)

这两种方式都会产生不同的优点和缺点,并且没有明显优越的解决方案.简单原则要求我们决定其中一个,并且多数决定是关于printf +读/写.

我想知道我执行"itoa"功能是否正确.也许你可以帮我把它变得更"正确",我很确定我错过了什么.(也许已经有一个库按我想要的方式进行转换,但是......找不到任何东西)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

char * itoa(int i) {
  char * res = malloc(8*sizeof(int));
  sprintf(res, "%d", i);
  return res;
}

int main(int argc, char *argv[]) {
 ...

没有任何替代品atof,strtod,lexical_cast,stringstream或sprintf？

那是:

1. 快速
2. C++方式(std::string代替char*)
3. 安全(没有缓冲区溢出风险)
4. 有效(如果无法进行转换,则返回NaN)
5. 没有外部库(独立)

我更喜欢这个,一个简单的功能,优化,并在一定程度上

原因:

• atof并且strtod是C函数,它们不会NaN在失败时返回,我更喜欢继续工作std::string,所以我只是问是否有人已经写了一些std::string我可以使用的包装器(如果你不介意的话).
• lexical_cast 有依赖性
• stringstream 是慢的
• sprintf 有缓冲区溢出风险及其C函数

我正在运行一些基准测试,以找到最有效的方法将大型数组写入C++文件(ASCII中超过1Go).

所以我将std :: ofstream与fprintf进行了比较(参见下面我使用的开关)

    case 0: {
        std::ofstream out(title, std::ios::out | std::ios::trunc);
        if (out) {
            ok = true;
            for (i=0; i<M; i++) {
                for (j=0; j<N; j++) {
                    out<<A[i][j]<<" ";
                }
                out<<"\n";
            }
            out.close();
        } else {
            std::cout<<"Error with file : "<<title<<"\n";
        }
        break;
    }
    case 1: {
        FILE *out = fopen(title.c_str(), "w");
        if (out!=NULL) {
            ok = true;
            for (i=0; i<M; i++) {
                for (j=0; j<N; j++) {
                    fprintf(out, "%d ", A[i][j]);
                }
                fprintf(out, "\n");
            }
            fclose(out);
        } else …

我知道C/C++中的字符串文字具有静态存储持续时间,这意味着它们"永远"存在,即只要程序运行.

因此,如果我有一个非常频繁调用的函数并使用字符串文字,如下所示:

void foo(int val)
{
    std::stringstream s;
    s << val;
    lbl->set_label("Value: " + s.str());
}

set_label函数将a const std::string&作为参数.

我应该使用const std::string这里而不是字符串文字还是没有区别？

我需要尽可能减少运行时内存消耗.

编辑:

我的意思是将字符串文字与const std::string prefix("Value: ");在某种常量头文件中初始化的字符串文字进行比较.

此外,这里的连接返回一个临时的(让我们调用它,Value: 42并将一个对这个临时的const引用传递给函数set_text(),我是否正确？

再次感谢你!