小编Ste*_*hen的帖子

设计iOS应用程序的推荐方法是什么？例如,如果有多个标签或文本视图,如何在一个地方更新字体样式/颜色更新所有其他位置的样式/颜色？

我知道子分类可能是一种方式......还有其他方法吗？

我开始质疑"extern"关键字的用处,该关键字用于访问其他模块中的变量/函数(在其他文件中).当我们使用#include预处理器导入带有变量/函数原型或函数/变量定义的头文件时,我们不是在做同样的事吗？

union
{ int i;
  bool b;
} x;

x.i = 20000;
x.b = true;
cout << x.i;

打印出19969.为什么不打印出20000？

在以下代码段中将是:

• 功能的结果
• x的值
• y的值

    {
         unsigned int x=-1;
         int y;
         y = ~0;
         if(x == y)
             printf("same");
         else
             printf("not same");
     }

a. same, MAXINT, -1
b. not same, MAXINT, -MAXINT
c. same , MAXUINT, -1
d. same, MAXUINT, MAXUINT
e. not same, MAXINT, MAXUINT

有人可以解释我的工作原理或者只是解释一下片段吗？

我知道它是关于两个补码n等.MAXINT和-1的意义是什么？这是因为unsigned int和int的事情 - 我是对的吗？

我对C++的字符串相当新手,所以下面的模式可能有点难看.在开始使用更大的系统进行集成测试之前,我正在查看我编写的一些代码.我想知道的是它是否安全,或者是否容易泄漏内存？

string somefunc( void ) {
    string returnString;
    returnString.assign( "A string" );
    return returnString;
}

void anotherfunc( void ) {
    string myString;
    myString.assign( somefunc() );
    // ...
    return;
}

我的理解是,returnString的值被分配给一个新对象myString,然后在解析对somefunc的调用时销毁returnString对象.在myString超出范围的某个时候,它也会被破坏.

我通常会将指向myString的指针传递给somefunc()并直接分配给myString的值,但我正在努力使我的代码更清晰(并且更少依赖副作用函数样式).

gcc抱怨这个:

#include <stdio.h>
static const int YY = 1024;
extern int main(int argc, char*argv[])
{  
  static char x[YY];
}

$ gcc -c test1.c test1.c:在函数main': test1.c:5: error: storage size ofx'中不是常量test1.c:5:错误:变量`x'的大小太大

从x的定义中删除"静态",一切都很好.

我不清楚这里发生了什么:肯定YY 是不变的？

我一直认为"静态const"方法比"#define"更可取.在这种情况下有没有办法使用"静态const"？

为什么下面的代码不起作用？我的意思是,它在控制台输出上显示各种奇怪的字符.

#include <stdio.h>
char mybuffer[80];
int main()
{
    FILE * pFile;
    pFile = fopen ("example.txt","r+");
    if (pFile == NULL) perror ("Error opening file");

    else {
        fputs ("test",pFile);

        fgets (mybuffer,80,pFile);
        puts (mybuffer);
        fclose (pFile);
        return 0;
    }
}

但是,下面的代码运行良好.

#include <stdio.h>
char mybuffer[80];
int main()
{
    FILE * pFile;
    pFile = fopen ("example.txt","r+");
    if (pFile == NULL) perror ("Error opening file");

    else {
        fputs ("test",pFile);
        fflush (pFile);    
        fgets (mybuffer,80,pFile);
        puts (mybuffer);
        fclose (pFile);
        return 0;
    }
}

为什么我需要刷新流以获得正确的结果？

有时我看到函数定义如下:

read_dir(dir)
char    *dir;   
{
        DIR * dirp;
        struct dirent *d;

        /* open directory */
        dirp = opendir(dir);
  ......... so  on

这里声明的重要性是什么

char    *dir;

在函数名称之后很快声明指针然后启动函数体的内涵是什么.

我试图了解C,通过K&R.我无法理解本书中的两个函数的代码:

void qsort(int v[], int left, int right){
int i, last;

void swap(int v[], int i, int j);

if (left >= right)
    return;

swap(v, left, (left+right)/2);

last = left;

for ( i = left+1; i<=right; i++)
    if (v[i]<v[left])
        swap(v,++last, i);

swap(v,left,last);
qsort(v,left,last-1);
qsort(v,last+1,right);
}


void swap(int v[], int i, int j){

    int temp;

    temp = v[i];
    v[i] = v[j];
    v[j] = temp;
}

这两个函数对给定的数组执行快速排序.在main函数中,我创建了一个int数组并调用了qsort.它编译得很好并且运行良好.我的问题是,为什么swap()的原型放在函数qsort()而不是main()之前？

我有一个缓冲区,我正在做很多strncat.我想确保我永远不会溢出缓冲区大小.

char buff[64];

strcpy(buff, "String 1");

strncat(buff, "String 2", sizeof(buff));

strncat(buff, "String 3", sizeof(buff));

而不是sizeof(buff),我想说一些buff - xxx.我想确保我永远不会覆盖缓冲区