c.c语录

c.c语录篇一

CC++编程新手错误语录

1.

2.

3.

4.

5.

6.

7.

8.

9.

10.

"

11. 12.

13.

14.

15.

16. "我的程序都是对的，可结果不对" "程序=算法+数据结构" "程序编出来，运行正确就行了" "数组名就是指针" "整形变量为32位" "switch和if „else„可随意替换" "免得麻烦，把类里面的成员函数都搞成public算了" "我想用malloc"、"我用不好malloc" "函数add编译生成的符号就是add" "没见过在C语言中调用C++的函数"、"C/C++不能调用Basic、Pascal语言的函数"英语、数学不好就学不好C/C++" "C++太难了，我学不会" "整型变量仅仅意味着一个整数" "值传递一定不会改变参数" "C不高级，学C++、JAVA、C#才够味" "语言学得越多越好"

(1)“我的程序都是对的，可结果不对”

想想你的周围，是不是也有人说这样的话？如果你也曾经说过，那就此打住，不要再说这句话，因为这句话只会显示说话者的无知。既然程序都是对的，那为什么结果不对？

(2)“程序=算法+数据结构”

如果刚刚学完C语言，我们说这样的话，完全可以理解，而且可以说是正确的。但是如果你是一位即将从事C/C++编程的程序员，那么很遗憾，这个说法只能判错，殊不知，世界上还有另一种说法：

程序 = 对象+ 消息

“程序=算法+数据结构”只对面向过程的语言(C)成立，而对面向对象的语言（C++），则只能表述为“程序=对象+消息”。传统的过程式编程语言以过程为中心以算法为驱动，面向对象的编程语言则以对象为中心以消息为驱动。这里的消息是广义的，对象A调用了对象B的成员函数，可看作对象A给B发消息。

(3)“程序编出来，运行正确就行了”

运行正确的程序并不一定是好程序，程序员时刻要牢记的一条就是自己写的程序不仅是给自己看的，要让别人也能轻易地看懂。很遗憾，许多的编程新手不能清晰地驾驭软件的结构，对头文件和实现文件的概念含糊不清，写出来的程序可读性很差。

C程序采用模块化的编程思想，需合理地将一个很大的软件划分为一系列功能独立的部

分合作完成系统的需求，在模块的划分上主要依据功能。模块由头文件和实现文件组成，对头文件和实现文件的正确使用方法是： 规则1 头文件(.h)中是对于该模块接口的声明，接口包括该模块提供给其它模块调用的外部函数及外部全局变量，对这些变量和函数都需在.h中文件中冠以extern关键字声明；

规则2 模块内的函数和全局变量需在.c文件开头冠以static关键字声明；

规则3 永远不要在.h文件中定义变量；

许多程序员对定义变量和声明变量混淆不清，定义变量和声明变量的区别在于定义会产生内存分配的操作，是汇编阶段的概念；而声明则只是告诉包含该声明的模块在连接阶段从其它模块寻找外部函数和变量。如：

/*模块1头文件：module1.h*/

int a = 5; /* 在模块1的.h文件中定义int a */

/*模块１实现文件：module1 .c*/

#include “module1.h” /* 在模块1中包含模块1的.h文件 */

/*模块2实现文件： module2.c*/

#include “module1.h” /* 在模块2中包含模块1的.h文件 */

/*模块2 实现文件：module3 .c*/

#include “module1.h” /* 在模块3中包含模块1的.h文件 */

以上程序的结果是在模块1、2、3中都定义了整型变量a，a在不同的模块中对应不同的地址单元，这明显不符合编写者的本意。正确的做法是：

/*模块1头文件：module1.h*/

extern int a; /* 在模块1的.h文件中声明int a */

/*模块１实现文件：module1 .c*/

#include “module1.h” /* 在模块1中包含模块1的.h文件 */

int a = 5; /* 在模块1的.c文件中定义int a */

/*模块2 实现文件： module2 .c*/

#include “module1.h” /* 在模块2中包含模块1的.h文件 */

/*模块3 实现文件： module3 .c*/

#include “module1.h” /* 在模块3中包含模块1的.h文件 */

这样如果模块1、2、3操作a的话，对应的是同一片内存单元。

规则4 如果要用其它模块定义的变量和函数，直接包含其头文件即可。

许多程序员喜欢这样做，当他们要访问其它模块定义的变量时，他们在本模块文件开头添加这样的语句：

extern int externVar;

抛弃这种做法吧，只要头文件按规则1完成，某模块要访问其它模块中定义的全局变量时，只要包含该模块的头文件即可。

(4)“数组名就是指针”

许多程序员对数组名和指针的区别不甚明了，他们认为数组名就是指针，而实际上数组名和指针有很大区别，在使用时要进行正确区分，其区分规则如下：

规则1 数组名指代一种数据结构，这种数据结构就是数组；

例如：

char str[10];

char *pStr = str;

cout << sizeof(str) << endl;

cout << sizeof(pStr) << endl;

输出结果为：

10

4

这说明数组名str指代数据结构char[10]。

规则2 数组名可以转换为指向其指代实体的指针，而且是一个指针常量，不能作自增、自减等操作，不能被修改；

char str[10];

char *pStr = str;

str++; //编译出错，提示str不是左值

pStr++; //编译正确

规则3 指向数组的指针则是另外一种变量类型（在WIN32平台下，长度为4），仅仅意味着数组的存放地址；

规则4 数组名作为函数形参时，在函数体内，其失去了本身的内涵，仅仅只是一

个指针；很遗憾，在失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。

例如：

void arrayTest(char str[])

{

cout << sizeof(str) << endl; //输出指针长度

str++; //编译正确

}

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

{

char str1[10] = "I Love U";

arrayTest(str1);

return 0;

}

(5)“整形变量为32位”

整形变量是不是32位这个问题不仅与具体的CPU架构有关，而且与编译器有关。在嵌入式系统的编程中，一般整数的位数等于CPU字长，常用的嵌入式CPU芯片的字长为8、16、32，因而整形变量的长度可能是8、16、32。在未来64位平台下，整形变量的长度可达到64位。

长整形变量的长度一般为CPU字长的2倍。

在数据结构的设计中，优秀的程序员并不会这样定义数据结构（假设为WIN32平台）： typedef struct tagTypeExample

{

unsigned short x;

unsigned int y;

}TypeExample;

他们这样定义：

#define unsigned short UINT16 //16位无符号整数

#define unsigned int UINT32 //32位无符号整数

typedef struct tagTypeExample

{

UINT16 x;

UINT32 y;

}TypeExample;

这样定义的数据结构非常具有通用性，如果上述32平台上的数据发送到16位平台上接收，在16位平台上仅仅需要修改UINT16、UINT32的定义：

#define unsigned int UINT16 //16位无符号整数

#define unsigned long UINT32 //32位无符号整数

几乎所有的优秀软件设计文档都是这样定义数据结构的。

(6)“switch和if „else„可随意替换”

switch语句和一堆if„else„的组合虽然功能上完全一样，但是给读者的感受完全不一样。if„else„的感觉是进行条件判断，对特例进行特别处理，在逻辑上是“特殊与一般”的关系，而switch给人的感觉是多个条件的关系是并列的，事物之间不存在特殊与一般的关系，完全“对等”。

譬如：

//分别对1-10的数字进行不同的处理，用switch

switch(num)

{

case 1:

„

case 2:

„

}

//对1-10之间的数字进行特殊处理，用if

if(num < 10 && num > 1)

{

„

}

else

{

„

}

许多时候，虽然不同的代码可实现完全相同的功能，但是给读者的感觉是完全不同的。譬如无条件循环：

while(1)

{

}

有的程序员这样写：

for(;;)

{

}

这个语法没有确切表达代码的含义，我们从for(;;)看不出什么，只有弄明白for(;;)在C/C++语言中意味着无条件循环才明白其意。而不懂C/C++语言的读者看到while(1)也可猜到这是一个无条件循环。

(7)“免得麻烦，把类里面的成员函数都搞成public算了”

许多人编C++程序的时候，都碰到这样的情况，先前把某个成员函数定义成类的

private/protected函数，后来发现又要从外面调用这个函数，就轻易地将成员函数改为public类型的。甚至许多程序员为了避免访问的麻烦，干脆把自己添加的成员函数和成员变量都定义成public类型。

殊不知，这是一种规划的失败。在类的设计阶段，我们就要很清晰地知道，这个类的成员函数中哪些是这个类的接口，哪些属于这个类内部的成员函数和变量。一般的准则是接口（public成员）应在满足需求的前提下尽可能简单！

所以不要轻易地将private/protected成员改为public成员，真正的工作应该在规划阶段完成。

(8)“我想用malloc”、“我用不好malloc”

来看看一个变态程序：

/* xx.c：xx模块实现文件 */

int *pInt;

/* xx模块的初始化函数 */

xx_intial()

{

pInt = ( int * ) malloc ( sizeof( int ) );

...

}

/* xx模块的其他函数（仅为举例）*/

xx_otherFunction()

{

*Int = 10;

...

}

这个程序定义了一个全局整型变量指针，在xx模块的初始化函数中对此指针动态申请内存，并将pInt指向该内存首地址，并在xx模块的其他函数中都使用pInt指针对其指向的整数进行读取和赋值。

c.c语录篇二

C语言语句格式讲解

C语言运算讲解

1.

#include <iostream.h>

#include <stdio.h>

void main()

{

int a=3,b=4,c=5,d,e,f,h; /*定义整形变量,并给部分变量赋初值*/

d=a+b>c&&b= =c; /*&&是逻辑“与”，即逻辑乘，顺序从左到右判断表达式的真假*/ /*即先算a+b是7,再判断7>c(c=5)是否成立,成立为真,即1,不成了为假,

即0,在判断b,c是否相等,即b= =c，相等为真1,不想等为假0，再把

&&两侧的真假进行“与运算”，运算结果赋给d*/

printf("d=%d\n",d); /*十进制输出d=0 */

e=a||b+c&&b>c; /*||表示“或”运算，即相加,在数电中,非0即1，但C语言中，1，2，

3….都为逻辑1。e=a||b+c&&b>c=3+4+5*0(b>c不成立为假0)=7即1*/

printf("e=%d\n",e); /*输出e=1*/

f=!a||!b||c; /*“！”叹号表示逻辑“非”，即取反，f=!3+!4+5=5即1*/ printf("f=%d\n",f); /*输出f=1*/

h=a*b&&c+a; /*h=3*4*5+3=63,即1*/

printf("h=%d\n",h); /*输出h=1*/

}

2.

1）

#include <iostream.h>

#include <stdio.h>

void main()

{

int a=6,b=7,c,d; /*定义整形变量并给a,b赋初值*/

a*=b*=b; /*等式从右向左计算，先计算b*=b，其含义是b=b*b=7*7=49;a*=x意思是 /a=a*x。所以a*=意思是a=a*b*b=6*49=294最后结果 a=294,b=49 */ printf("a=%d,b=%d\n",a,b); /* 输出a=%d是十进制整数输出格式说明，输几个说几个,\n表示回车*/ }

2）

#include <iostream.h>

#include <stdio.h>

void main()

{

int a=6,b=7,c,d; /*定义变量的值a=6,b=7,和变量c，d*/

c=b/=a; /* b/=a意思是b=b/a=7/6=1（int是整数，b取整）， c=b=1，结果a=6,b=1,c=1 */ printf("a=%d,b=%d,c=%d\n",a,b,c);

3）

#include <iostream.h>

#include <stdio.h>

void main()

{

int a=6,b=7,c,d; /*定义变量的值a=6,b=7,和变量c，d*/

a+=b-=a; /*b-=a意思是b=b-a=7-6=1，a+=b，意思是a=a+b=6+1=7

printf("a=%d,b=%d\n",a,b); /*输出结果上下两行a=7,b=1*/

}

4）

#include <iostream.h>

#include <stdio.h>

void main()

{

int a=6,b=7,c,d; /*int a=6，b=7，和整形变量c，d*/

a+=b+=a*=b;

printf("a=%d,b=%d\n",a,b); /* a*=b意思是a=a*b=6*7=42; b+=a*意思是b=a+b=42+7=49，

/*a+=b意思是a=a+b=42+49=91，最后结果 a=91,b=49*/

}

5）

#include <iostream.h>

#include <stdio.h>

void main()

{

int a=6,b=7,c,d; /*int a=6，b=7，和整形变量c，d*/

c=a+=b+=a; /* b+=a意思是b=b+a=13; a+=b意思是a=a+b=6+13=19 ; c=a =19,b=13,c=19*/

printf("a=%d,b=%d,c=%d\n",a,b,c);

}

6）{c.c语录}.

#include <iostream.h>

#include <stdio.h>

void main()

{

int a=6,b=7,c,d; /*int a=6，b=7，和整形变量c，d*/

d=(c=a/b+15); /* c=a/b+15; d=c; a=6,b=7,c=15,d=15*/

printf("a=%d,b=%d,c=%d,d=%d\n",a,b,c,d);

}

6.

1）

#include <stdio.h>

void main()

{

int a=5,b=8,c=9,x,y,z;

y=(a+b,c+a); /* 括号内用","逗号隔开的表达式从左到右依次运算，但把最右边的赋给y*/

/*把最后一个运算作为结果赋给变量y，y=（a+b=5+8=13，c+a=14）*/

printf ("y=%d\n",y); */最后运算c+a=14，所以，y=14*/

｝

2）

#include <stdio.h>

void main()

{

int a=5,b=8,c=9,x,y,z;

x=y=a,z=a+b; /*仍为","x=y=a，相当于先算最右边的y=a=5，x=y=5;z=a+b=5+8=13*/ printf ("x=%d,y=%d,z=%d\n",x,y,z); /*x=5，y=5，z=13*/

｝

3）

#include <stdio.h>

void main()

{

int a=5,b=8,c=9,x,y,z;{c.c语录}.

y=(x=a*b,x+x,x*x); /*仍为","运算，从左向右先算x=a*b=5*8=40,再x+x=40+40=80,x*x=40*40=1600)

/*赋最后的1600给y*/

printf ("y=%d\n",y); /* y= 1600*/

｝

4.)

#include <stdio.h>

void main()

{

int a=5,b=8,c=9,x,y,z;

x=(y=a,z=a+b); /*仍为","运算，x=(y=a,z=a+b)=(y=a=5,z=a+b=5+8=13),把最后z=13给X*/

printf ("x=%d\n",x); /*x=13*/

}

5)

1)

#include <stdio.h>

void main()

{

int a=15,b=18,c=21,x,y;{c.c语录}.

x=a<b||c++; /*逻辑“或”运算，从左到右，a=15<b=18为真即1,||或运算1“或”任何数为1,x=1，*/

/*注意：或前为1，后面表达式不再运算，所以，abc的值不变*/

/*printf ("x=%d,a=%d,b=%d,c=%d\n",x,a,b,c);/* x=1, a=15,b=18,c=21*/

2)

#include <stdio.h>

void main()

{

int a=15,b=18,c=21,x,y;

y=a>b&&c++; /*逻辑“与”运算，从左到右，a=15>b=18为假,即0, */

/*&&或运算0“与”任何数为0,y=0，注意：&&前为0，*/

} /*后面表达式不再运算，所以，abc的值不变*/ printf ("y=%d,a=%d,b=%d,c=%d\n",y,a,b,c);/* y=0, a=15,b=18,c=21*/

3)

#include <stdio.h>

void main()

{

int a=15,b=18,c=21,x,y;

x=a+b>c&&c++;/*逻辑“或”运算，从左到右，a+b=33>c=21为真即1,*/

/*运算符合&&前为1，再运算后面表达式，c++即c=c+1=22，*/

/*所以，ab不变c=22 */

printf ("x=%d,a=%d,b=%d,c=%d\n",x,a,b,c);结果，x=0，a=15，b=18，c=22*/

4)

#include <stdio.h>

void main(){c.c语录}.

{

int a=15,b=18,c=21,x,y;

y=a||b++||c++; /* 因为a=15为逻辑1（非0数），或运算||前为1，后面不再算，*/

/*所以，a=15，b=18,c=21不变，y=1*/

printf ("y=%d,a=%d,b=%d,c=%d\n",y,a,b,c);/* y=1 ，a=15，b=18,c=21*/

}

5）

#include <stdio.h>

void main()

{

inta,b; /*定义a，b为整形变量，即整数*/

float x,y; /*定义x，y为浮点数，即实数，可为小数*/

x=a=7.873; /*结果，从右向左，7.873浮点数，但a为整数，a=7，x=a，但x为浮点，所以*/ /*x=7.000000，默认小数点后是6位， */

printf ("x=%f,a=%d\n",x,a);/*若在该语句中的x=%f的f后加个“点n”即“. n”可保留n位。*/

a=x=7.873; /*结果，从右向左，7.873浮点数，x也为浮点，x=7.873000，但a为整数，a=7*/ printf ("x=%f,a=%d\n",x,a); /*x=7.873000，a=7 */

x=a=y=7.873; /*从右向左，7.873浮点数，y也为浮点，y=7.873000，但a为整数，a=7，在把a的值7*/

赋给x，所以，x=7.000000*/

printf ("x=%f,a=%d,y=%f\n",x,a,y); /*x=7.000000，a=7，y=7.873000*/

b=x=(a=25,15/2); /*先算除法15/2,，注意，除法运算整数相除结果取整，若出发运算中一个数为实数*/

/*15和2都为整数，则15/2=7，再把25赋给a，即a=25，这又是一个逗号运算，*/

/*把最后面的15/2=7赋给x，则x=7.000000，不为整数再把x=7.000000的整数部分7*/

赋给b，所以b=7*/

printf ("b=%d,x=%f,a=%d\n",b,x,a);/*输出b=7，x=7.000000，a=257*/

}

c.c语录篇三

俞敏洪经典语录~2954C

俞敏洪名言

蜗牛的壳是自己加上的。

蜗牛只要爬到金字塔顶端，它眼中所看到的世界，它收获的成就，跟雄鹰是一模一样的。

大海无边，只取你能饮的，我能饮的那瓢水肯定就是我最想喝的那瓢水。{c.c语录}.

创业其实比生孩子容易，一个人就可以了，都不需要两个人。

创业的时候，千万不要将自己当人看。

把我所有的东西都让给他们，就是为让他们跟着我走。

共富贵难有一个利益分配的问题，共患难的时候，大家首先想到以后会富贵。原则上如果提前讲好利益分配原则，共富贵不难，可怕的是共患难的时候，没有想到将来有利益分配。

我比较像刘备，常常用眼泪来赚取其他管理者的同情，我不擅长用纪律来限制和管理人才。

千万不要形成三国演义的局面，你一到新城市就得把这个江山打下来，否则就别做。为什么？因为最后形成你一家跟另两家争霸的时候，所有的成本都消耗在了人力资源和市场广告上，最后可能什么收益都没有。那还不如派个比较强势的人，花一大笔钱一揽子把对方全给收并过来，这样就变成一个独立王国了，独立王国的成本是最低的。

一块砖没有什么用，一堆砖也没有什么用，如果你心中没有一个造房子的梦想，拥有天下所有的砖头也是一堆废物；但如果只有造房子的梦想，而没有砖头，梦想也没法实现。

每条河流都有一个梦想：奔向大海。长江、黄河都奔向了大海，方式不一样。长江劈山开路，黄河迂回曲折，轨迹不一样。但都有一种水的精神。水在奔流的过程中，如果沉淀于泥沙，就永远见不到阳光了。

每一条河流都有自己不同的生命曲线，但是每一条河流都有自己的梦想——那就是奔向大海。我们的生命，有的时候会是泥沙。你可能慢慢地就会像泥沙一样，沉淀下去了。一旦你沉淀

下去了，也许你不用再为了前进而努力了，但是你却永远见不到阳光了。所以我建议大家，不管你现在的生命是怎么样的，一定要有水的精神。像水一样不断地积蓄自己的力量，不断地冲破障碍。当你发现时机不到的时候，把自己的厚度给积累起来，当有一天时机来临的时候，你就能够奔腾入海，成就自己的生命。（《水的精神》）

人的生活方式有两种，第一种方式是像草一样活着，你尽管活着，每年还在成长，但是你毕竟是一棵草，你吸收雨露阳光，但是长不大。人们可以踩过你，但是人们不会因为你的痛苦，而他产生痛苦；人们不会因为你被踩了，而来怜悯你，因为人们本身就没有看到你。所以我们每一个人，都应该像树一样的成长，即使我们现在什么都不是，但是只要你有树的种子，即使你被踩到泥土中间，你依然能够吸收泥土的养分，自己成长起来。当你长成参天大树以后，遥远的地方，人们就能看到你；走近你，你能给人一片绿色。活着是美丽的风景，死了依然是栋梁之才，活着死了都有用。这就是我们每一个同学做人的标准和成长的标准。（《人要像树一样活着》）

做人像水，做事像山。做人尽量往低处走，让着别人，遇见利益和名声尽可能往下退，给自己留下做大的余地。做事一定要有自己的主见和目标，像山一样挺立在那儿，才能把事做好。

如果我们的生命不为自己留下一些让自己热泪盈眶的日子，你的生命就是白过的。

只有两种人的成功是必然的。第一种是经过生活严峻的考验，经过成功与失败的反复交替，最后终于成大器。另一种没有经过生活的大起大落，但在技术方面达到了顶尖的地步。比如学化学的人最后成为世界著名的化学家，这也是成功。

没有任何外面的力量能把一个人或者一个机构打败，能把一个人打败的是自己的内心世界，把一个机构打败的是内部的管理。

信念是来自于一种内心的力量，当你内心有足够的信念时，你就不一定需要外在的信仰。（《信念与激情》）

你宁可跟一群优秀的人打交道，你是最后一名，像他们去学习，不管怎么被他们挤压，

都不能是在一群没有出息的人中间你变成了第一名。

你想知道自己的价值有多少，看看你身边的朋友，选出5个朋友，他们价值的平均值就是你的价值。

上市以后俞敏洪是不是感觉自己身价不一样了？一头猪被贴上了一个新的标签，觉得自己不是猪了，这是一个很危险的事情，这是我对自己的告诫。

我后悔上市，我现在依然后悔上市。

名次和荣誉，就像天上的云，不能躺进去，躺进去就跌下来了。名次和荣誉其实是道美丽的风景，只能欣赏。

大家就惊慌失措了。因为我们之前从来没有学过商业规则，从来没有学过股份制，连有限公司和无限公司都搞不清楚是怎么回事。我们没有这个能力来拆分这种利益躯体。

在新东方，骨干们很容易越过规矩谈感情。上市之后，外部规矩比内部规矩更强大、更有力。

如果说新东方从最初的发展到做大的过程中还有我许多主动因素的话，上市从本质上来说是一直被推着走的。外来竞争对手算一个推力，内在的推动更厉害，因为公司发展到一定程度后，大家都拿了新东方的股权，股权变现是每个人都关心的问题。能一下子拿到钱而且从某种意义上来说不需要承担太多后果，那当然是大家很希望的。当然，新东方最终还是被推上市了，其中一部分原因是为了化解内部矛盾，否则新东方内部的人、循环在内部圈子里的人大家搅和，搅和到最后都觉得没有出头之日。

原来我在新东方可以随便鼓动员工，现在这种话绝对不敢说了，只能说能做到的事情。原来说话从来不拿稿子，现在说话一定要拿提纲。另外还有一个有意思的现象，现在大家觉得我有钱了，求助信像雪片式地飞过来了，各种各样的机构和个人。有的明显是有杀富济贫的感觉。

在北大的时候，买活鱼还是死鱼我都要犹豫半天。

有财富未必有人生，有人生未必无财富。