c和c++主要区别

摘选自《C++ Primer Plus》第6版

c和c++主要区别

根据书中的描述，进行了整理

一、 源代码文件的扩展名

摘自1.4.1

C++实现	源代码文件的扩展名
UNIX	C、cc、cxx、c
GNU C++	C、cc、cxx、cpp、c++
Digital Mars	cpp、cxx
Borland C++	cpp
Watcom	cpp
Microsoft Visual C++	cpp、cxx、cc
Freestyle Code Warrior	cp、cpp、cc、cxx、c++

另外UNIX系统上的C程序的扩展名为.c

 

二、变量定义

摘自2.2.1

c语言中，全部的局部变量必须在函数或复合语句开始位置，c++没有这个限制。

void main()  
{  
      int a;  //define variable a
      int b;  //define variable b
   
      a = 10;  
      printf("a=%d \n", a);  
   
      b = 11;  
      printf("b=%d \n", b); 

      {   
              int temp = 0;

              printf("test variable in processing\n");
      }   
}

注释：

a、局部变量a和b位于函数开始位置，变量temp位于复合语句的开始位置。

b、复合语句（摘自5.1.10）：使用两个花括号来构造一条复合语句（代码块）。代码块由一对花括号和它们包含的语句组成。

 

三、 auto

摘自3.4.5

c语言中， auto用于声明变量为自动变量，auto修饰符的定义里有这么一句“进入包含变量声明的代码时，变量开始存在。当程序离开这个代码块时，自动变量消失了。它所占用的内存可用来作别的事情。”，从“当程序离开代码块时变量消失”、“内存可用来作别的事情”能够推出auto修饰的变量是存储在堆栈中的。而全局变量存储在静态存储区中，因此用auto决不能修饰全局变量。

C++11标准引入auto类型说明符，用它就能让编译器替咱们去分析表达式所属的类型。

与原来那些只对应一种特定类型的说明符不一样，auto让编译器经过初值来推算变量类型。显然，auto定义的变量必需要有初始值。

auto i=0,*p=&i;         //正确，i是整数，p是整形指针

 

四、stuct

摘自4.4

在C语言中, struct类型的定义必须加上struct的前缀

struct opt {
        int len;
        int value;
};


void main()  
{  
      struct opt tmp;

      tmp.len = 1;
      tmp.value = 2;
}

而在C++中，struct能够直接使用其类型名来定义

#include <iostream>
struct opt {
        int len;
        int value;
};

int main()
{
        opt tmp;
        tmp.len = 1;
        tmp.value = 2;

        std::cout<<tmp.len<<std::endl;
        std::cout<<tmp.value<<std::endl;

        return 0;
}

 

相比之下，C++的语法更简洁一些。因此在用C语言编写代码的时候，C程序员一般是这么来定义的struct的。在下面的代码中，使用typedef来定义一个opt的类型

typedef struct _opt {
        int len;
        int value;
}opt;


void main()  
{  
      opt tmp;

      tmp.len = 1;
      tmp.value = 2;

}

 

五、stuct初始化

摘自4.4.2

与数组同样，c++11也支持将列表初始化用于结构，且等号（=）是可选的：

opt tmp {1, 2};

其中不容许缩窄转换，例如：

opt tmp {1.0, 2};

编译报错：

error: narrowing conversion of ‘1.0e+0’ from ‘double’ to ‘int’ inside { }

 

c语言可使用列表初始化，可是等号（=）是必须的。

opt tmp = {1,2};

 

六、枚举的取值范围

摘自4.6.2

c++如今经过强制类型转换，增长了能够赋值给枚举变量的合法值。

每一个枚举都有取值范围，经过强制类型转换，能够将取值范围中的任何整数赋值给枚举变量，即便这个值不是枚举值例如，假设bits 和myflag 的定义以下：

enum bits{ one=1,two=2,four=4,eight=8};

 bits myflag;

则下面的代码是合法的：

myflag=bits(6);//正确，由于 6在bits的范围

取值范围的定义：首先，要找出上限，须要知道枚举量的最大值。找到大于这个最大值的、最小的2的幂，将它减去1，获得的即是取值范围的上限。

例如对于:
 

enum bigstep{first,second = 100,third};

最大枚举值是101,在2的幂中,比这个值大的最小的值为128,所以取值范围上限为127.

要知道下限,须要知道枚举量的最小值.若是它不小于0,则取值范围的下限为0.不然,采起与寻找上限方式一样的方式,但加上负号,

例如,若是最小的枚举量为-6,则比它小的,2的幂最大的值为-8,加1以后为-7.因而,上限与下限便能算出来.

 

c语言中不能定义这样的变量：bits myflag;

七、for循环

摘自5.1

C++11新增一种循环：基于范围（range-based）的for循环：简化一种常见的循环任务：对数组（或容器类，如vector和array）的每一个元素执行相同的操做.

格式以下：

for(Type VarName : Array){
  　　//每一个元素的值会依次赋给 VarName
}

示例：

double prices[5]={4.99, 2.33, 5.86, 6.42, 4.51};  
for (double x : prices)  
      std::cout<<x<<std::endl;

 

八、逻辑运算符的另外一种表示

摘自6.2.6

并非全部的键盘都提供了用做逻辑运算符的符号，标识符and、or和not都是c++保留字，这意味着不能将它们用做变量名等。它们不是关键字，由于它们都是已有语言特性的另外一种表示方式。另外，它们并非c语言中的保留字，但c语言程序能够将它们用做运算符，只要在程序中包含了头文件iso646.h.

逻辑运算符：另外一种表示方式

运算符	另外一种表示方式
&&	and
||	or
!	not

 

九、c++字符库函数cctype

摘自6.3

cctype中一般包括一些经常使用函数的判断，如某个字符是否为大写，用isupper()若是参数是大写字母，函数返回true, 还有像isalnum(),若是参数是字母数字，即字母或者数字，函数返回true.

 

函数名称   返回值

isalnum()  若是参数是字母数字，即字母或者数字，函数返回true

isalpha()   若是参数是字母，函数返回true

isblank()   若是参数是水平制表符或空格，函数返回true

iscntrl()     若是参数是控制字符，函数返回true

isdigit()     若是参数是数字（0－9），函数返回true

isgraph()   若是参数是除空格以外的打印字符，函数返回true

islower()    若是参数是小写字母，函数返回true

isprint()      若是参数是打印字符（包括空格），函数返回true

ispunct()    若是参数是标点符号，函数返回true

isspace()   若是参数是标准空白字符，如空格、换行符、水平或垂直制表符，函数返回true

isupper()   若是参数是大写字母，函数返回true

isxdigit()     若是参数是十六进制数字，即0－九、a－f、A－F，函数返回true

tolower()    若是参数是大写字符，返回其小写，不然返回该参数

toupper()   若是参数是小写字符，返回其大写，不然返回该参数

 

10 、wchar_t 和C++11新增类型：char16_t char32_t

摘自3.1.8

wcha_t：

wchar_t是C/C++的字符类型，是一种扩展的存储方式，主要用在国际化程序的实现中。

wchar_t 存在的缘由：

char是八位字符类型，最多能包含256中字符，许多的外文字符集所包含的字符数目超过256个，char型不能表示。

wchar_t数据大小：

数据类型通常为16或者32位，不一样的C/C++库有不一样的规定。总之：wchar_t所能表示的字符远远多于char类型。

wchar_t的输入输出处理：

cin和cout将输入和输出看做是char流，所以不适合用于处理wchat类型，iostream头文件提供了wcin 和wcout用于处理输入输出流另外能够经过加上前缀L来只是宽字符常量和宽字符串。

 

char16_t和char32_t:

产生缘由：

随着编程人员日益的熟悉Unicode，类型wchar_t显然已经知足不了需求，在计算机系统上进行的编码字符和字符串编码时，仅仅使用Unicode码点显然是不够的，

好比：若是在进行字符串编码时，若是有特定长度和符号特征的类型将颇有帮助，而类型wchar_t的长度和符号特征随实现而已，所以C++11新增了类型char16_t,char32_t。

char16_t:无符号类型，长16位，

char32_t无符号类型，长32位

C++11使用前缀u表示char16_t字符常量和字符串常量如：u‘L’；u“lilili”;

C++11使用前缀U表示char32_t字符常量和字符串常量如：U'L';U"lilili";

类型char16_t与/u00F6形式的通用字符名匹配，

类型char32_t与/U0000222B形式的通用字符名匹配。

前缀u和U分别指出字符字面值的类型为char16_t和char32_t。

 

十一、函数重载

摘自8.4

C++ 容许多个函数拥有相同的名字，只要它们的参数列表不一样就能够，这就是函数的重载（Function Overloading）。借助重载，一个函数名能够有多种用途。

void test(int tmp1, int tmp2)
{

        std::cout << tmp1 <<std::endl;
        std::cout << tmp2 <<std::endl;
}

void test(double tmp1, double tmp2)
{

        std::cout << tmp1 <<std::endl;
        std::cout << tmp2 <<std::endl;
}

函数的重载的规则：

    函数名称必须相同。
    参数列表必须不一样（个数不一样、类型不一样、参数排列顺序不一样等）。
    函数的返回类型能够相同也能够不相同。
    仅仅返回类型不一样不足以成为函数的重载。

C++ 是如何作到函数重载的
C++代码在编译时会根据参数列表对函数进行重命名。当发生函数调用时，编译器会根据传入的实参去逐个匹配，以选择对应的函数，若是匹配失败，编译器就会报错，这叫作重载决议（Overload Resolution）。

 

在C语言中，不存在函数重载，缘由为以函数名来惟一区分一个全局函数。 而在c++中 以函数名+参数列表来惟一区分函数。

 

十二、引用

摘自8.2

引用（reference）是c++对c语言的重要扩充。引用就是某一变量（目标）的一个别名，对引用的操做与对变量直接操做彻底同样。其格式为：类型 &引用变量名 = 已定义过的变量名。

引用的特色：
1. 一个变量可取多个别名。
2. 引用必须初始化。
3. 引用只能在初始化的时候引用一次 ，不能更改成转而引用其余变量。

总结：
1. 不要返回一个临时变量的引用。
2. 若是返回对象出了当前函数的做用域依旧存在，则最好使用引用返回，由于这样更高效。

* 引用和指针的区别和联系
1. 指针是一个实体，而引用仅是个别名；
2. 引用使用时无需解引用(*)，指针须要解引用；
3. 引用只能在定义时初始化一次，以后不能改变指向其它变量（从一而终）；指针变量的值可变。
4. 引用必须指向有效的变量，指针能够为空。
5. sizeof指针对象和引用对象的意义不同。sizeof引用获得的是所指向的变量的大小，而sizeof指针是对象地址的大小。
6. 指针和引用自增(++)自减(--)意义不同。
7. 相对而言，引用比指针更安全。
8. 从内存分配上看：程序为指针变量分配内存区域，而引用不须要分配内存区域。

* 相同点：二者都是地址的概念，指针指向一起内存，其内容为所指内存的地址；引用是某块儿内存的别名。

指针比引用更为灵活，可是其风险也很大。使用指针时必定要检查指针是否为空(NULL)，且空间回收后指针最好置零，以避免野指针的发生形成内存泄漏等问题。

#include <iostream>

int main()
{
        struct student{
                std::string name;
                int num;
        };

        student lily = {"andrew", 168};
        const student &ref = lily;
        student *p = &lily;


        std::cout << sizeof ref<< "= sizeof ref\n";
        std::cout << sizeof p<< "= sizeof pointer\n";
}

执行结果：

16= sizeof ref
8= sizeof pointer