那是因为你没有理解scanf_s的用法，_s是safe，即安全的意思，那么如何保证安全呢，当这个函数试图读取c或者s时，需要为它传递缓冲区最大长度，因为我们只读取1字符，所以要传1，
正确调用如下：
scanf_s("%lf%c%lf", &first_number, &character, 1, &second_numble);
注意加粗的1，表示只读取1个长度的缓冲区，并存储在character变量里
内存异常访问的原因是你的调用没有传这个1，相当于少了一个参数，那么最后一个参数即second_numble的地址是一个错乱的值，导致了内存访问错误。
同理，scanf_s("%c", &command_begin);的调用也是错误的，需要加一个参数1
其实这些都是有警告的，大概你忽略掉了。
⑵ java教程与c语言教程冲突吗有联系吗
没有冲突的，可以同时学，因为C++是从C语言诞生而来，java又是从C++诞生而来，所以是有很大联系的，当然，经过这么久的发展，各个语言已经各有特色了，但是最好还是学完一个再学一个，这样学的会比较深入
希望我的回答对您有所帮助！
⑶ c语言 写入位置时发生访问冲突是怎么回事儿
c语言 写入位置时发生访问冲突是设置错误造成的，解决方法为：
1、用VS2013打开程序。
⑷ c语言中发生冲突访问
scanf_s改成scanf
或者
scanf_s("%f%c%f",&a,&c,1,&b);
输入公式的时候，数值与运算符中间加空格。
如果不想这样，就要修改代码，把公式当一个字符串来输入，代码中再来提取运算值和运算符，再进行计算即可。
有一种代码可以将这种中缀表达式转为后缀表达式，再进行计算，可以计算比这复杂的多的公式，比如可以计算带括号的复杂公式。
⑸ C语言 读取位置 发生冲突
没有仔细看代码，怀疑是内存泄露或指针使用的问题，建议单步跟踪测试，以确定故障点。
⑹ c语言调试中断，说冲突
for(i=0;i<10;i++)
{
if(a[i]>t)
{
for(j=9;j<=i;j--)a[j+1]=a[j];//你的循环终止条件有问题
}
else a[10]=t;
}
printf("the true is");
for(i=0;i<11;i++)printf(" %d ",a[i]);
}
⑺ C语言 数据结构中解决冲突的方法是什么
可以参考如下方法：
1 基本原理
使用一个下标范围比较大的数组来存储元素。可以设计一个函数（哈希函数， 也叫做散列函数），使得每个元素的关键字都与一个函数值（即数组下标）相对应，于是用这个数组单元来存储这个元素；也可以简单的理解为，按照关键字为每一个元素"分类"，然后将这个元素存储在相应"类"所对应的地方。
但是，不能够保证每个元素的关键字与函数值是一一对应的，因此极有可能出现对于不同的元素，却计算出了相同的函数值，这样就产生了"冲突"，换句话说，就是把不同的元素分在了相同的"类"之中。后面我们将看到一种解决"冲突"的简便做法。
总的来说，"直接寻址"与"解决冲突"是哈希表的两大特点。
2 函数构造
构造函数的常用方法（下面为了叙述简洁，设 h(k) 表示关键字为 k 的元素所对应的函数值）：
a) 除余法：
选择一个适当的正整数 p ，令 h(k ) = k mod p
这里， p 如果选取的是比较大的素数，效果比较好。而且此法非常容易实现，因此是最常用的方法。
b) 数字选择法：
如果关键字的位数比较多，超过长整型范围而无法直接运算，可以选择其中数字分布比较均匀的若干位，所组成的新的值作为关键字或者直接作为函数值。
3 冲突处理
线性重新散列技术易于实现且可以较好的达到目的。令数组元素个数为 S ，则当 h(k) 已经存储了元素的时候，依次探查 (h(k)+i) mod S , i=1,2,3…… ，直到找到空的存储单元为止（或者从头到尾扫描一圈仍未发现空单元，这就是哈希表已经满了，发生了错误。当然这是可以通过扩大数组范围避免的）。
4 支持运算
哈希表支持的运算主要有：初始化(makenull)、哈希函数值的运算(h(x))、插入元素(insert)、查找元素(member)。
设插入的元素的关键字为 x ，A 为存储的数组。
初始化比较容易，例如
const empty=maxlongint; // 用非常大的整数代表这个位置没有存储元素
p=9997; // 表的大小
procere makenull;
var i:integer;
begin
for i:=0 to p-1 do
A[i]:=empty;
End;
哈希函数值的运算根据函数的不同而变化，例如除余法的一个例子：
function h(x:longint):Integer;
begin
h:= x mod p;
end;
我们注意到，插入和查找首先都需要对这个元素定位，即如果这个元素若存在，它应该存储在什么位置，因此加入一个定位的函数 locate
function locate(x:longint):integer;
var orig,i:integer;
begin
orig:=h(x);
i:=0;
while (i<S)and(A[(orig+i)mod S]<>x)and(A[(orig+i)mod S]<>empty) do
inc(i);
//当这个循环停下来时，要么找到一个空的存储单元，要么找到这个元
//素存储的单元，要么表已经满了
locate:=(orig+i) mod S;
end;
插入元素
procere insert(x:longint);
var posi:integer;
begin
posi:=locate(x); //定位函数的返回值
if A[posi]=empty then A[posi]:=x
else error; //error 即为发生了错误，当然这是可以避免的
end;
查找元素是否已经在表中
procere member(x:longint):boolean;
var posi:integer;
begin
posi:=locate(x);
if A[posi]=x then member:=true
else member:=false;
end;
这些就是建立在哈希表上的常用基本运算。
4.1 应用的简单原则
什么时候适合应用哈希表呢？如果发现解决这个问题时经常要询问："某个元素是否在已知集合中？"，也就是需要高效的数据存储和查找，则使用哈希表是最好不过的了！那么，在应用哈希表的过程中，值得注意的是什么呢？
哈希函数的设计很重要。一个不好的哈希函数，就是指造成很多冲突的情况，从前面的例子已经可以看出来，解决冲突会浪费掉大量时间，因此我们的目标就是尽力避免冲突。前面提到，在使用"除余法"的时候，h(k)=k mod p ，p 最好是一个大素数。这就是为了尽力避免冲突。为什么呢？假设 p=1000 ，则哈希函数分类的标准实际上就变成了按照末三位数分类，这样最多1000类，冲突会很多。一般地说，如果 p 的约数越多，那么冲突的几率就越大。
简单的证明：假设 p 是一个有较多约数的数，同时在数据中存在 q 满足 gcd(p,q)=d >1 ，即有 p=a*d , q=b*d, 则有 q mod p= q - p* [q div p] =q - p*[b div a] . ① 其中 [b div a ] 的取值范围是不会超过 [0，b] 的正整数。也就是说， [b div a] 的值只有 b+1 种可能，而 p 是一个预先确定的数。因此 ① 式的值就只有 b+1 种可能了。这样，虽然mod 运算之后的余数仍然在 [0，p-1] 内，但是它的取值仅限于 ① 可能取到的那些值。也就是说余数的分布变得不均匀了。容易看出， p 的约数越多，发生这种余数分布不均匀的情况就越频繁，冲突的几率越高。而素数的约数是最少的，因此我们选用大素数。记住"素数是我们的得力助手"。
另一方面，一味的追求低冲突率也不好。理论上，是可以设计出一个几乎完美，几乎没有冲突的函数的。然而，这样做显然不值得，因为这样的函数设计很浪费时间而且编码一定很复杂，与其花费这么大的精力去设计函数，还不如用一个虽然冲突多一些但是编码简单的函数。因此，函数还需要易于编码，即易于实现。
综上所述，设计一个好的哈希函数是很关键的。而"好"的标准，就是较低的冲突率和易于实现。
⑻ c语言访问内存冲突，这该怎么办啊
、C中内存分为四个区
栈：用来存放函数的形参和函数内的局部变量。由编译器分配空间，在函数执行完后由编译器自动释放。
堆：用来存放由动态分配函数（如malloc）分配的空间。是由程序员自己手动分配的，并且必须由程序员使用free释放。如果忘记用free释放，会导致所分配的空间一直占着不放，导致内存泄露。
全局局：用来存放全局变量和静态变量。存在于程序的整个运行期间，是由编译器分配和释放的。
文字常量区：例如char *c = “123456”；则”123456”为文字常量，存放于文字常量区。也由编译器控制分配和释放。
程序代码区：用来存放程序的二进制代码。
例子(一)
int a = 0; //全局区
void main()
{
int b; //栈
char s[] = abc; //s在栈,abc在文字常量区
char *p1,*p2; //栈
char *p3 = 123456; //123456在常量区，p3在栈上
static int c =0; //全局区
p1 = (char *)malloc(10); //p1在栈，分配的10字节在堆
p2 = (char *)malloc(20); //p2在栈，分配的20字节在堆
strcpy(p1, 123456); //123456放在常量区
}
例子(二)
//返回char型指针
char *f()
{
//s数组存放于栈上
char s[4] = {'1','2','3','0'};
return s; //返回s数组的地址，但程序运行完s数组就被释放了
}
void main()
{
char *s;
s = f();
printf (%s, s); //打印出来乱码。因为s所指向地址已经没有数据
}
2、动态分配释放内存
用malloc动态分配内存后一定要判断一下分配是否成功，判断指针的值是否为NULL。
内存分配成功后要对内存单元进行初始化。
内存分配成功且初始化后使用时别越界了。
内存使用完后要用free（p）释放，注意，释放后，p的值是不会变的，仍然是一个地址值，仍然指向那块内存区，只是这块内存区的值变成垃圾了。为了防止后面继续使用这块内存，应在free(p)后，立即p=NULL，这样后面如果要使用，判断p是否为NULL时就会判断出来。
NO.1
void GetMemory(char *p)
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str,hello world);
printf(str);
}
请问运行Test函数后会是什么样的结果？
NO.2
char *GetMemory(void)
{
char p[] = hello world;
retrun p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
}
问题同NO.1
NO.3
void GetMemory2(char **p, int num)
{
*p = (char *)malloc(num);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str,100);
strcpy(str,hello);
printf(str);
}
问题同NO.1
NO.4
void Test(void)
{
char *str = (char *)malloc(100);
strcpy(str,hello);
free(str);
if(str != NULL)
{
strcpy(str,world);
printf(str);
}
}
问题同NO.1
我对以上问题的分析：
NO.1：程序首先申请一个char类型的指针str,并把str指向NULL（即str里存的是NULL的地址，*str为NULL中的值为0），调用函数的过程中做了如下动作：1申请一个char 类型的指针p，2把str的内容到了p里（这是参数传递过程中系统所做的）,3为p指针申请了100个空间，4返回Test函数．最后程序把字符串hello world拷贝到str指向的内存空间里．到这里错误出现了！str的空间始终为NULL而并没有实际的空间．深刻理解函数调用的第2步，将不难发现问题所在！（建议：画图理解）
NO.2：程序首先申请一个char类型的指针str,并把str指向NULL．调用函数的过程中做了如下动作：1申请一数组p[]并将其赋值为hello world(数组的空间大小为12)，2返回数组名p付给str指针（即返回了数组的首地址）．那么这样就可以打印出字符串＂hello world＂了么？当然是不能的！因为在函数调用的时候漏掉了最后一步．也就是在第2步return数组名后，函数调用还要进行一步操作，也就是释放内存空间．当一个函数被调用结束后它会释放掉它里面所有的变量所占用的空间．所以数组空间被释放掉了，也就是说str所指向的内容将不确定是什么东西．
NO.3：正确答案为可以打印出hello．但内存泄漏了！
NO.4：申请空间，拷贝字符串，释放空间．前三步操作都没有任何问题．到if语句里的判断条件开始出错了，因为一个指针被释放之后其内容并不是NULL，而是一个不确定的值．所以if语句永远都不能被执行．这也是着名的＂野＂指针问题．所以我们在编写程序释放一个指针之后一定要人为的将指针付成NULL．这样就会避免出现＂野＂指针的出现．有人说＂野＂指针很可怕，会带来意想不到的错误．
C语言内存对齐
C99规定int、unsigned int和bool可以作为位域类型，但编译器几乎都对此作了扩展，允许其它类型类型的存在。
使用位域的主要目的是压缩存储，其大致规则为：
1) 如果相邻位域字段的类型相同，且其位宽之和小于类型的sizeof大小，则后面的字段将紧邻前一个字段存储，直到不能容纳为止；
2) 如果相邻位域字段的类型相同，但其位宽之和大于类型的sizeof大小，则后面的字段将从新的存储单元开始，其偏移量为其类型大小的整数倍；
3) 如果相邻的位域字段的类型不同，则各编译器的具体实现有差异，VC6采取不压缩方式，Dev-C++采取压缩方式；
4) 如果位域字段之间穿插着非位域字段，则不进行压缩；
5) 整个结构体的总大小为最宽基本类型成员大小的整数倍。
还是让我们来看看例子。
示例1：
struct BF1
{
char f1 : 3;
char f2 : 4;
char f3 : 5;
};
其内存布局为：
|_f1__|__f2__|_|____f3___|____|
|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
0 3 7 8 1316
位域类型为char，第1个字节仅能容纳下f1和f2，所以f2被压缩到第1个字节中，而f3只能从下一个字节开始。因此sizeof(BF1)的结果为2。
示例2：
struct BF2
{
char f1 : 3;
short f2 : 4;
char f3 : 5;
};
由于相邻位域类型不同，在VC6中其sizeof为6，在Dev-C++中为2。
示例3：
struct BF3
{
char f1 : 3;
char f2;
char f3 : 5;
};
什么是内存对齐
考虑下面的结构：
struct foo
{
char c1;
short s;
char c2;
int i;
};
假设这个结构的成员在内存中是紧凑排列的，假设c1的地址是0，那么s的地址就应该是1，c2的地址就是3，i的地址就是4。也就是
c1 00000000, s 00000001, c2 00000003, i 00000004。
可是，我们在Visual c/c++ 6中写一个简单的程序：
struct foo a;
printf("c1 %p, s %p, c2 %p, i %p/n",
(unsigned int)(void*)&a.c1 - (unsigned int)(void*)&a,
(unsigned int)(void*)&a.s - (unsigned int)(void*)&a,
(unsigned int)(void*)&a.c2 - (unsigned int)(void*)&a,
(unsigned int)(void*)&a.i - (unsigned int)(void*)&a);
运行，输出：
c1 00000000, s 00000002, c2 00000004, i 00000008。
为什么会这样？这就是内存对齐而导致的问题。
为什么会有内存对齐
以下内容节选自《Intel Architecture 32 Manual》。
字，双字，和四字在自然边界上不需要在内存中对齐。（对字，双字，和四字来说，自然边界分别是偶数地址，可以被4整除的地址，和可以被8整除的地址。）
无论如何，为了提高程序的性能，数据结构（尤其是栈）应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；然而，对齐的内存访问仅需要一次访问。
一个字或双字操作数跨越了4字节边界，或者一个四字操作数跨越了8字节边界，被认为是未对齐的，从而需要两次总线周期来访问内存。一个字起始地址是奇数但却没有跨越字边界被认为是对齐的，能够在一个总线周期中被访问。
某些操作双四字的指令需要内存操作数在自然边界上对齐。如果操作数没有对齐，这些指令将会产生一个通用保护异常（#GP）。双四字的自然边界是能够被16整除的地址。其他的操作双四字的指令允许未对齐的访问（不会产生通用保护异常），然而，需要额外的内存总线周期来访问内存中未对齐的数据。
编译器对内存对齐的处理
缺省情况下，c/c++编译器默认将结构、栈中的成员数据进行内存对齐。因此，上面的程序输出就变成了：
c1 00000000, s 00000002, c2 00000004, i 00000008。
编译器将未对齐的成员向后移，将每一个都成员对齐到自然边界上，从而也导致了整个结构的尺寸变大。尽管会牺牲一点空间（成员之间有空洞），但提高了性能。
也正是这个原因，我们不可以断言sizeof(foo) == 8。在这个例子中，sizeof(foo) == 12。
如何避免内存对齐的影响
那么，能不能既达到提高性能的目的，又能节约一点空间呢？有一点小技巧可以使用。比如我们可以将上面的结构改成：
struct bar
{
char c1;
char c2;
short s;
int i;
};
这样一来，每个成员都对齐在其自然边界上，从而避免了编译器自动对齐。在这个例子中，sizeof(bar) == 8。
这个技巧有一个重要的作用，尤其是这个结构作为API的一部分提供给第三方开发使用的时候。第三方开发者可能将编译器的默认对齐选项改变，从而造成这个结构在你的发行的DLL中使用某种对齐方式，而在第三方开发者哪里却使用另外一种对齐方式。这将会导致重大问题。
比如，foo结构，我们的DLL使用默认对齐选项，对齐为
c1 00000000, s 00000002, c2 00000004, i 00000008，同时sizeof(foo) == 12。
而第三方将对齐选项关闭，导致
c1 00000000, s 00000001, c2 00000003, i 00000004，同时sizeof(foo) == 8。
如何使用c/c++中的对齐选项
vc6中的编译选项有 /Zp[1|2|4|8|16] ，/Zp1表示以1字节边界对齐，相应的，/Zpn表示以n字节边界对齐。n字节边界对齐的意思是说，一个成员的地址必须安排在成员的尺寸的整数倍地址上或者是n的整数倍地址上，取它们中的最小值。也就是：
min ( sizeof ( member ), n)
实际上，1字节边界对齐也就表示了结构成员之间没有空洞。
/Zpn选项是应用于整个工程的，影响所有的参与编译的结构。
要使用这个选项，可以在vc6中打开工程属性页，c/c++页，选择Code Generation分类，在Struct member alignment可以选择。
要专门针对某些结构定义使用对齐选项，可以使用#pragma pack编译指令。指令语法如下：
#pragma pack( [ show ] | [ push | pop ] [, identifier ] , n )
意义和/Zpn选项相同。比如：
#pragma pack(1)
struct foo_pack
{
char c1;
short s;
char c2;
int i;
};
#pragma pack()
栈内存对齐
我们可以观察到，在vc6中栈的对齐方式不受结构成员对齐选项的影响。（本来就是两码事）。它总是保持对齐，而且对齐在4字节边界上。
验证代码
#include <stdio.h>
struct foo
{
char c1;
short s;
char c2;
int i;
};
struct bar
{
char c1;
char c2;
short s;
int i;
};
#pragma pack(1)
struct foo_pack
{
char c1;
short s;
char c2;
int i;
};
#pragma pack()
int main(int argc, char* argv[])
{
char c1;
short s;
char c2;
int i;
struct foo a;
struct bar b;
struct foo_pack p;
printf("stack c1 %p, s %p, c2 %p, i %p/n",
(unsigned int)(void*)&c1 - (unsigned int)(void*)&i,
(unsigned int)(void*)&s - (unsigned int)(void*)&i,
(unsigned int)(void*)&c2 - (unsigned int)(void*)&i,
(unsigned int)(void*)&i - (unsigned int)(void*)&i);
printf("struct foo c1 %p, s %p, c2 %p, i %p/n",
(unsigned int)(void*)&a.c1 - (unsigned int)(void*)&a,
(unsigned int)(void*)&a.s - (unsigned int)(void*)&a,
(unsigned int)(void*)&a.c2 - (unsigned int)(void*)&a,
(unsigned int)(void*)&a.i - (unsigned int)(void*)&a);
printf("struct bar c1 %p, c2 %p, s %p, i %p/n",
(unsigned int)(void*)&b.c1 - (unsigned int)(void*)&b,
(unsigned int)(void*)&b.c2 - (unsigned int)(void*)&b,
(unsigned int)(void*)&b.s - (unsigned int)(void*)&b,
(unsigned int)(void*)&b.i - (unsigned int)(void*)&b);
printf("struct foo_pack c1 %p, s %p, c2 %p, i %p/n",
(unsigned int)(void*)&p.c1 - (unsigned int)(void*)&p,
(unsigned int)(void*)&p.s - (unsigned int)(void*)&p,
(unsigned int)(void*)&p.c2 - (unsigned int)(void*)&p,
(unsigned int)(void*)&p.i - (unsigned int)(void*)&p);
printf("sizeof foo is %d/n", sizeof(foo));
printf("sizeof bar is %d/n", sizeof(bar));
printf("sizeof foo_pack is %d/n", sizeof(foo_pack));
return 0;
}
⑼ c语言相关的几个问题
这些人回答的都很好，你仔细仔细再仔细的看下吧
回答者： dixnuits - 大魔法师 八级 2009-5-9 21:49
1.不过时，不会过时，如果过时了其他语言也过时了，c语言是基础，其他很多语言都是基于c语言开发的
2.肯定合适
3.c是面向过程的，c++是面向对象的。
回答者： znzhang - 门吏 三级 2009-5-9 21:50
1.没有。不会。除非人们不再用计算机编程。只要还在用计算机，就会有人用C语言编程的，虽然现在大部分人认为面向对象的JAVA或者其它的比C语言容易上手的，可是如果你学过了C语言，再去学其它的软件，就会发现有了C语言的基础，学什么都很简单的。但是如果你先学了其它的编程语言，再学C语言，发现C语言还是很基础的，它比一般的汇编要容易懂些，比面向对象的又相对简单，属于接口类型、承上启下，是不可多得的语言。
2.适合。现在大学里依然开的是C语言，用的依然是谭浩强的《C程序设计》，况且现在的二级还是以C语言作为考试内容。想要学习好语言，必需从基础的开始学起，所以从最基本的C语言开始是最适合不过了。不过要想学好它，必需要有耐心才行。
3. C是面向过程的程序设计语言。C＋＋是面向对象的程序设计语言，不过C＋＋语言保持了对C语言的兼容，也就说是在C＋＋程序可以不用修改的插入C语言代码。不过最开始还是C语言适合入门。
回答者： 小马232 - 大魔法师 九级 2009-5-9 21:54
首先声明下 我也在学C语言 从C中感到乐趣 就像现在在网络知道回答问题 并不是为了那么点分数，我也要看题目，一旦遇到自己会作出来的，绝对不会再做，看到模棱两可的会拿出来做做，现在越来越对C感兴趣，下面回答你的问题，声明只是个人建议
1.C语言永远不会过时，它是所有编程的基础，着种算法，可以变成很多的程序，但是有一定的局限性，所有有了C++
2.完全可以的，C语言是基础，学好了C，学其他的语言就简单了，不过要有很大的耐心的，因为做程序设计的很累的
3.C是算法着重过程，而c++是面向对象的，两者不冲突，没有C也可以学C++，c可以编才程序c++也可以编
回答者： chenlg1102 - 初入江湖 二级 2009-5-9 21:57
1.c语言是最为基础的语言,可以说永远不会过时,而且现在的应用面非常之广,c语言在驱动,硬件方面有着不可动摇的地位.作为一个程序员,你可以不会Java,C#,但不可以不会C.
2.看看现在大学安排的课程就知道了,C语言基本都是第一学期就开的
3.C是一个结构化语言，如谭老爷子所说：它的重点在于算法和数据结构。C程序的设计首要考虑的是如何通过一个过程，对输入（或环境条件）进行运算处理得到输出（或实现过程（事务）控制），而对于C++，首要考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题域，这样就可以通过获取对象的状态信息得到输出或实现过程（事务）控制。
所以C与C++的最大区别在于它们的用于解决问题的思想方法不一样。之所以说C++比C更先进，是因为" 设计这个概念已经被融入到C++之中 "，而就语言本身而言，在C中更多的是算法的概念。那么是不是C就不重要了，错！算法是程序设计的基础，好的设计如果没有好的算法，一样不行。而且，"C加上好的设计"也能写出非常好的东西。
对语言本身而言，C是C++的子集，那么是什么样的一个子集？从上文可以看出， C实现了C++中过程化控制及其它相关功能，而在C++中的C（我称它为"C+"），相对于原来的C还有所加强，引入了重载、内联函数、异常处理等等玩艺儿，C++更是拓展了面向对象设计的内容，如类、继承、虚函数、模板和包容器类等等。
再提高一点，在C++中，数据封装、类型这些东东已不是什么新鲜事了，需要考虑的是诸如：对象粒度的选择、对象接口的设计和继承、组合与继承的使用等等问题。
所以相对于C，C++包含了更丰富的"设计"的概念，但C是C++的一个自洽子集，也具有强大的功能，同样值得学习。
回答者： imabeau - 助理 三级 2009-5-9 21:57
1. 在操作系统、 比较底层的编程、 嵌入式 等方面，除了C语言几乎没有其它选择。 所以相当长时间内不可能过时
2. 随便，哪种语言都有的学。 当然javascript之类的就别当回事了。。
3. 从本意上说，C++是C语言的面向对象的扩充。 但扩充的结果是失去了一些C语言原有的优势和特点， 所以所谓“C++是更好的C” 或者“C++是面向对象的C”这种幻想已经是破灭了。 现实情况是，在使用方向上C++和C语言已经分道扬镳， C++的优势在大型软件的快速开发
回答者： vbtraz - 高级魔法师 七级 2009-5-9 21:58
1.C没过时，也不会过时，C可以直接和硬件打交道，别的高级语言都做不到，所以别写操作系统就用它.
2.学C把，谁然C的现实用处不多，但是它是让你学个习惯，打基础的语言。
3.C++和C没关系的，发明C++的人 建议我们直接学C++
回答者： ijlynietg - 同进士出身 六级 2009-5-9 22:44
1.c语言过时了吗？回过时吗？如果会那什么时候回过时？如果不会 为什么？
绝对不会过时。因为涉及底层的开发c还是非常优秀的
2.可以，程序书写上还是多参考规范，c语言不够严谨
3.c++是c的超集，更灵活，在大规模程序上更易维护，但也注定了它与底层的结合不是很好
回答者： wanfustudio - 副总裁 十级 2009-5-9 22:55
1,c语言在本世纪还不会过时，c语言是比较基础的语言
2，最好从汇编开始，很多病毒，高级的程序都是汇编程序，
3，我同意c++是c语言的拓充（我是先学的C，c++几乎包含所有的C的内容）
回答者： chengjie_ - 江湖新秀 四级 2009-5-10 00:18
说实话，你的问题根本没人可以完整回答，再资深的人也不可能决定你的前途。
首先说过时问题，何谓“过时”，好，就算有你说的“过时”，那C不会是在世界各地一齐过时吧，总得慢慢过时吧。
其次适合从哪里学，得看你想以后做什么，也就是说得有个前提。
最后说区别，很多，多的我都罗列不出来，就算罗列出来了，你也未必看的明白，就算你最后费劲看明白了，那也估计你自己学的也差不多了，所以我就甭费劲复制粘贴了。
重要的是要抓紧一切时间开始做，问切实的问题，做的多了，自然就明白了，其实就那么点事，不要把别人说的看成是自己的。
回答者： 可咸 - 举人 四级 2009-5-10 00:20
我哥哥是驻日本软件工程师。天天逼着我学C 这不1个多月了 还真学了不少东西
C是基础 就像1+1 ,没C C++学起来就很困难 学了C C++就容易多了
回答者： 遇见′伏笔 - 试用期 一级 2009-5-10 00:57
C语言 不会过时的...可以把他当做一种基础来学习，你学习了他 再去学习别的语言如C++ 就会容易 好多...
我们就是学的C语言 C++ 可以看做C的拓展。C++支持面向对象功能的程序设计语言，而C语言是面向过程的程序设计语言，它不但具有C语言的短小精练，使用方便的特点，还在原来的基础上，使类型更严格，使用更方便。C++面向对象 C面向过程 。
我觉得 可以 从C开始学起，这样你学别的语言就会更容易了。
虽然语言不一样，只是换个单词 ，实际一个意思的。
有用的东西 怎么可能过时啊 是吧？ 加油！ 还有汇编语言等你学呢，嘿嘿..不过好难哦！希望你是 这类语言的奇才...努力吧！
回答者： 管管的面面 - 初入江湖 二级 2009-5-10 10:05
楼主，你好！
1、C不会过时。。简单说就是C是一种功能强大成熟的语言，小到单片机，大到几何级计算机都用可以用它。。而且在低层操作的除汇编之外，基本上没有比它更强的。。学C也是学其它语言的基础。。
2、学习C可以学习它的算法和数据结构。。这个是相当有用啊。。
3、C 和C++肯定有关系。。不是的话，那为什么C++不叫P++，Q++什么的。。C++的扩展名是cpp就是C Plus Plus的缩写。。
C是面向过程。C++是面向对向。
回答者： 资州纵寻 - 大魔导师 十二级 2009-5-10 10:50
回答：1：C语言不会过时，因为他是简单的入门语言程序，很普遍，新手必须学的，再高的手他也得会C语言。
回答：2：不一定，看个人爱好问题，但是有的东西也会涉及到C语言，你也可以从数据库学起，CF，CB啦之类，没有必须的开始位置。
回答：3：C语言也可以说是C++，但是版本不同一些命令和跳转语言也不一样，变化不太大，虽然方向不同，但是高点是一样的。
回答者： ctksmq520 - 初入江湖 二级 2009-5-10 18:01
1.C语言没过时，我不知道你是什么专业的，但在我专业里要学单片机（一种芯片，广泛用在日常生活和电子设备中，刷卡机，液晶显示，读卡器。。。等等中，只要你能看到的那些高级的设备都用到），就要求用C语言编程控制单片机实现功能的。不要以为C++等比他高级它就会过时，因为单片机高级语言只支持C语言。我参加全国的电子设计比赛，在产生正弦波，数模转化，液晶显示等方面，都用到单片机和C语言控制。全国电子设计大赛作为全国四大大学生比赛之一，学好单片机和C语言是必须的。你不要以为C语言只是用来做电脑软件的，那样的话是不实际的，C语言是用在硬件控制上。
2.如果你要学高级语言，我推荐你学C语言先，我现在都觉得C语言很实用，C语言的代码比较易懂，当我学了C语言再学c++和java，就觉得这两个只是在C上加了点东西。
3.C语言是面向过程的（注重过程的编写），C++是面向对象的（把过程分类，包装好，使用时直接调用），C语言就像制作的小零件，C++就像已经有了这些零件，把它组装成大机器，所以说c++功能强大。
回答者： 12121237 - 举人 四级 2009-5-11 16:23
可以的，任何一个开发语言都是独立的
回答者： 猪兵团 - 经理 四级 2009-5-12 08:44
1、C语言是学习其他高级语言的基础，所以不会过时
2、如果你是想学编程的，可以从c语言出发
3、如果你C语言学好了，学C++就会更容易，因为我现在就是在学计算机专业，第一个学期学的C语言，所以比较了解
还有什么不懂留言给我吧，呵呵`!
回答者： feng_liu0621 - 试用期 一级 2009-5-12 21:01
1如果你是初学者的话 绝对不过时!然而一切事物都有始终 但必须要有新事物替代 如果某天出现用自然语言编程的话 那它就过时了。
2 你作为初学者 如果真的想学好计算机语言的话 从c语言开始那是理所当然的
3 c和c++其实如果学了c后那它则是c的拓展 没学c则好像什么都不是 建议你慢慢来 ……
回答者： 锦阳之恋 - 试用期 一级 2009-5-13 00:41
首先楼主我接触C不到4个月,回答你这个问题不是为了拿分,只是不想楼主走弯路,C语言不会过时,当今很多人都在用C语言,因为C语言属于中高级语言,接近底层.当然汇编是另一种难以理解的语言,一个计算机爱好者可以看看C语言,了解数据结构,了解CPU,了解操作系统是最好不过的了.C语言和C++不相同,C语言用的是指针,而C++是面向对象,所以两者关系很小,有人说学习了C,然后学习C++就很好学,那是因为你明白了语言之间的逻辑,语言具有共通性,就像汉语跟外语有共同的地方.希望能给楼主一些好的想法.
61952645这是学习C语言的群,我们有自己的论坛www.6dtm.com专门学习各类关于电脑知识的论坛,欢迎你去看看
回答者： 冰冰_涛 - 助理 三级 2009-5-13 18:13
1、加法过时了吗？ 所谓的过时是说你不能用它找到工作，但是编程初学者从它学起很好；
2、c与c++的区别，你学了自然有你自己的理解。
回答者： az12xc34 - 兵卒 一级 2009-5-13 18:44
1. C语言再过50年也不会过时，有些很底层（比如操作系统）很注重效率（比如关系数据库）都必须拿C语言写的，偶尔嵌点汇编。
2. C语言很适合入门，不过前提是要有必要的计算机体系架构的知识，毕竟C语言很贴近硬件层，完全不懂计算机硬件知识会很难理解一些概念比如指针。既然是爱好者，推荐看一些大学计算机组成原理课程的教材。
3. C语言跟C++，从语法上说C++是C的超级，或者说C++是几乎完全兼容C的。但从开发理念上说，C++是面向对象，C语言是面向过程，可以说是分别代表了两个时代！如果要刨根问底，建议阅读《C++编程思想》，里面详细解释了C++是怎样在C的基础上一步步发展起来的，C++的每个主要特性各是解决了C语言的哪些缺陷。
回答者： catmonkeyxu - 见习魔法师 二级 2009-5-14 09:49
要了解C与C++的不同首先要了解C与C++的发展史！
C是在B的基础上发基础上发展起来的。1972年至1973间，贝尔实验室的D.M.Ritchie在B的基础上设计出了C语言。C语言既保持了BCPL和B语言的优点（精练，接近硬件），又克服了它们的缺点（过于简单，数据无类型等）。
C语言的优点： 1：语言简单、紧凑，使用方便、灵活。 2：运算符丰富。 3：数据类型丰富，具有现代语言的各种结构。 4：有结构化的控制语句（if…else,while,for等）。 5：语法限制不太严格，程序设计自由度大。 6：可以直接对硬件操作。 7：生成目标代码质量高，程序执行效率高。 8：可移值好！
C++是在C的基础上发展起来的，所以C++对C具有兼容性，即用C写的程序可以在C++上运行。就是因为C++对C具有兼容性所以C++在面向对象的设计语言中就失去了很多优势。比如指针，在其他语言中（如Java）中是没有的，C++兼容C所以一定要有的。C++是介于C与Java之间的过度语言，并不是完全的面向对象的语言。
再打个简单的比喻来说明C与C++之间的关系。我们可以把C比作是自行车那么C++就是电动自行车。自行车时速要是10千米每小时的话，那么电动自行车就可以达到20千米每小时。也就是说C++比C具有更强的功能。再有就是我们完全可以按照骑自行车的办法去骑电动自行车，这说明C++对C具有兼容性。再有就是电动自行车在没有电的情况下完全可以按照骑自行车的方法去骑电动自行车。这一点说明了C++在C的基础上发展而来的。
说了这多么应该对C与C++有所了解了吧。希望对你学习有所帮助!
回答者： aimilin6688 - 助理 三级 2009-5-16 14:03
1.没过时。不会过时。因为它可以直接对硬件进行操作。是其他语言无法完全代替的。
2.适合从C开始学。
3.c++是c语言的拓充不错，但是C也有C++无法代替的地方有的
人认为C++ > C那会让人笑掉大牙，不妨你去打听一下，现在有几个操作系统内核是用C++写的，又有几个实时系统用的是C++，当然我也不是说C++不好，但是目前的内核和实时系统中C++还无法与C匹敌，不过C++适合做应用系统的开发。所以我的观点是不在于你用什么语言，而在于你干什么工作。你的设计体现了你的技术层次。
一个初学者可以从C学起，再学C++就简单多了
回答者： cyj78117520 - 见习魔法师 二级 2009-5-17 10:38