小编A.s*_*lar的帖子

我是C#的新手.我刚刚使用Visual Studio运行C#'Hello World'程序.

我可以在不使用Visual Studio的情况下运行或编译C#程序吗？

如果可能,那么我应该使用哪个编译器？

谢谢

直到现在我才相信没有使用一元+算子.

但后来我遇到了以下示例:

char ch;
short sh;
int i;

printf("%d %d %d",sizeof(ch),sizeof(sh),sizeof(i)); // output: 1 2 4

printf("%d %d %d",sizeof(+ch),sizeof(+sh),sizeof(i)); // output: 4 4 4

这是否意味着+在这里进行类型转换？

因为它的行为与以下相同

printf("%d %d %d",sizeof((int)ch),sizeof((int)sh),sizeof(i)); // output: 4 4 4

这迫使我认为+是在进行类型转换.

但后来我尝试了 double

double f;
printf("%d %d",sizeof(+f),sizeof((int)f),sizeof(f));  // output: 8 4 8

这迫使我重新思考一元运算+符.

所以我的第二个问题是:一元+算子对算子有特殊影响sizeof吗？

我正在做宏的基础知识.我定义一个宏如下:

#define INTTOSTR(int) #int

将整数转换为字符串.

这个宏完美地将整数转换为字符串吗？我的意思是在某些情况下这个宏会失败吗？

我可以使用此宏来替换标准库函数itoa()吗？

例如:

int main()
{
    int a=56;
    char ch[]=INTTOSTR(56);
    char ch1[10];
    itoa(56,ch1,10);
    printf("%s %s",ch,ch1);
    return 0;
}

上述程序按预期工作.

有趣的是,这个宏甚至可以将float值转换为字符串.

例如:

INTTOSTR(53.5);

很好地工作.

直到现在我itoa在我的所有项目中使用函数将int转换为字符串.我可以itoa在所有项目中自信地替换.因为我知道使用宏的开销比函数调用少.

读完这篇文章后,我开始认为我已经学会了一个战利品printf().突然,我发现从下面的代码片段这本书:

int main()
{
    char str[]="Hello";
    int i=5,j=10;
    printf(i>j?"%50s":"%s",str); //unable to understand this 
    return 0;
}

令人惊讶的是,上面的代码运行没有错误,它打印Hello.根据我的知识,以下是语法printf():

int printf(const char *format,argument_list);

所以根据这种语法,printf()应该从格式字符串开始.但正如您在上面的代码中printf()所看到的那样i>j. 这是否意味着我在解释printf()的语法时出错了？将三元运算符放在printf()中是一种特殊情况吗？

编辑

我知道三元运算符我问的第一个参数printf()应该是const char*,我似乎不在我的例子中.

我知道typedef的简单定义:

typedef is a keyword in C to assign alternative names to types.

按照这个定义,我尝试实现typedef如下:

int main()
{
    typedef long mylong; //as per my knowledge after this statement mylong will be treated as long

    int long b;  // this works fine
    int mylong c; // but this gives error
}

我在gcc上尝试过这个.以下是错误

我知道这个错误意味着我没有得到typedef的实际概念.谁能告诉我哪里错了？

我对数组和指针感到很困惑.
请告诉我以下两个代码有什么区别？

int main()
{
    int i,*p;
    for(i=0;i<5;i++)
    {
        p[i]=i;
        printf("%d",p[i]);
    }
return 0;
}

int main()
{
    int i,p[5];
    for(i=0;i<5;i++)
    {
        p[i]=i;
        printf("%d",p[i]);
    }
return 0;
}

要重命名SQL中的任何表,我们使用以下命令:

RENAME OldTableName TO NewTableName

这在内部如何运作？

我的假设是它可能首先创建一个使用NewTableName的表AS SELECT,然后删除旧表DROP,就像我们在处理C中的文件时重命名文件一样.我是对的,还是以不同的方式工作？

该unchecked关键字已在MSDN库中解释为:

unchecked关键字用于抑制整数类算术运算和转换的溢出检查.在未经检查的上下文中,如果表达式生成的值超出目标类型的范围,则不会标记溢出.

根据定义,它在int类型上运行良好.

例如:

unchecked
{
   int i=2147483647+10;
}

这里它抑制了未经检查的块内的溢出.(它应该是)

但是当我们在字节上应用它时它不起作用

byte b1=100,b2=100,b3;
unchecked
{
   b3=b1+b2;//error here
}

因此,应该抑制在未经检查的环境中编写的任何内容.

为什么它会给出编译时错误？

或者我根本不理解未经检查的关键字？

但是,在优先级表中明确写出后缀运算符的优先级高于前缀.但我仍然有一个daubt.
我从以下示例开始:

*ptr++;   // evaluate as *(ptr++);
++*ptr;   // evaluate as ++(*ptr);

这证明后缀运算符的优先级高于前一个.

现在在下面的示例中,它似乎不正确:

int a=0,b,c;
b=a++;   //b=0 ,here it seems ++ has lower priority that is after assignment increment is performed.
c=++a;   //b=2 ,here it seems ++ has higher priority.

在上面的例子中,似乎postfix运算符的优先级低于前缀吗？

对不起,我不太善于解释问题.所以我直接从例子开始

请看下面的例子

const int a=10;
int *ptr;

int main(){
    ptr=&a; 
    *ptr=100;   // program crashes
    printf("%d",a);
}

但是,如果我在上面的代码中稍作修改,如下所示

const int a; // uninitialized global variable 

那么上面的代码工作正常.

所以我的问题是为什么编译器对uninitialize和初始化全局const变量的行为不同？

我正在使用gcc for windows(mingw).

对不起,我不太善于解释问题.我可以通过以下示例更好地解释我的问题:

string first = "hello";
string second = "Bye";
first = second;

在上面的例子中,考虑第三行first=second.
在这里,我将对象排在第二位.因为c#中的字符串是不可变的,即每次为现有字符串对象分配新值时,都会创建一个新对象,CLR将释放旧对象.(我从这里读到这个1).所以简单地说它意味着first第一行中的对象first与第三行中的对象不同.

所以我的问题是我怎样才能证明两者有所不同？
即如果它(字符串)在C中是可能的,那么我可以在第三个语句之前和之后打印两个对象的地址来证明它.
是否有任何方法可以访问那里的地址或其他替代方案？

众所周知,当整数变量超出其范围时,它从负数的另一端开始.
例如

int a=2147483648;
printf("%d",a);

输出:
-2147483648(正如我所料)

现在我尝试了相同的浮点数.
例如

float a=3.4e39;//as largest float is 3.4e38
printf("%f",a);

OUTOUT:
1.#INF00(我期待一些负浮动值)

我没有完全得到上面的输出,但我知道它代表正无穷大.
所以我的问题就是它为什么不从另一端开始(负值如整数)？

我尝试初始化struct变量如下:

struct Abc{
    char str[10];
};

int main(){
    struct Abc s1;
    s1.str="Hello";  //error
}

我可以理解这种行为,因为它是一样的

char str[10];
str="Hello"; // incompatible types

但请看下面的初始化

struct Abc s1={"Hello"};   //This is fine

struct Abc s2={.str="Hello"};  //This is also fine

我记得在毕业时,我读了很多教科书,说这些初始化都是一回事(即使用{}表示法初始化结构变量并明确使用(.)运算符是相同的事情).但上面的讨论证明它们并不相同.

我的问题是这些初始化之间究竟有什么区别？