C++和JAVA的区别是啥？

Posted 2023-04-09

C语言是经典的面向过程的编程语言，编程入门一般都学C语言以了解编程以及锻炼逻辑思维能力，在一些跟硬件比较紧密的编程中也经常用到。\x0d\x0a\x0d\x0aC++是在C语言的基础上加入了面向对象的概念，成为混合型面向对象语言，功能强大，但难度也大。\x0d\x0a\x0d\x0aJava是在C++的基础上进行改进的，摒弃了一些C++的不足之处，语法跟C++很像，它是运行在Java虚拟机上，所以可以跨平台，一处编译，到处执行。\x0d\x0a\x0d\x0a编程都是易学难精，哪个都好学，哪个又都不好学。都有很好的发展前景，就看是什么方向了。底层的C、桌面应用程序、游戏等等C++、嵌入式，网页，Java。 参考技术A

1、应用层不同

JAVA的应用在高层，C++在中间件和底层。

2、业务需求不同

JAVA离不开业务逻辑，而C++可以离开业务为JAVA们服务。

3、可移植性不同

java语言给开发人员提供了更为简洁的语法；取消了指针带来更高的代码质量；完全面向对象，独特的运行机制是其具有天然的可移植性。 java 是运行在JVM上的，之所以说它的可移植性强，是因为jvm可以安装到任何的系统。

c++不是不能在其他系统运行，而是c++在不同的系统上运行，需要不同的编码（这一点不如java，只编写一次代码，到处运行）。java程序一般都是生成字节码，在JVM里面运行得到结果。

4、应用平台优势不同

java 在web 应用上具有c++ 无可比拟的优势。java在桌面程序上不如c++实用，C++可以直接编译成exe文件，指针是c++的优势，可以直接对内存的操作，但同时具有危险性 。

（操作内存的确是一项非常危险的事情，一旦指针指向的位置发生错误，或者误删除了内存中某个地址单元存放的重要数据，后果是可想而知的）。

参考资料来源：百度百科-Java

参考资料来源：百度百科-c++

参考技术B Java程序中的每个变量要么是基本数据类型（boolean, char, byte, short, int, long, float, double），要么是对对象的引用

C++有许多种基本类型，额外还有struct, union, enum, 数组和指针，C++指针可以指向对象，也可以不指向对象

Java没有枚举、联合类型，因为Java认为没有必要。将可有可无的语言元素去掉是Java对C/C++做出的一大改变，因此，普遍认为Java较C++更轻便，更精简

Java采用Unicode字符集，C++通常用ASCII字符集。但ASCII是Unicode的子集，对于习惯于ASCII的程序员感觉不到区别

Java中的boolean类型不能转换成其他类型，反之亦然。C++最近引进了bool类型，代表布尔类型，整型也作为逻辑判断

模板是一种“泛型编程思想”，它有别于“面向对象编程思想”。C++在很大程度上已经支持了这种新型编程方法，特别是STL的出现
Java目前仍未支持泛型编程，不过据说Sun公司有在Java中引入模板的计划

C++支持“运算符的重载”，这是它的一个很重要的多态特征，是数据抽象和泛型编程的利器。它允许直接对对象进行四则运算，正像基本数据类型那样
Java不支持这种多态机制，也是为降低复杂性

两种语言都支持方法重载(overloading)

在C++中，为了允许运行时动态决定哪个函数被调用，一个函数必须用virtual修饰。virtual关键字被自动继承，用以支持多态

凡是没有用virtual修饰的成员函数（包括static）都是静态绑定的，即在编译时决定调用哪个版本

而在Java中，除了static、final、private是静态绑定以外，所有方法一律按动态绑定处理
C++中有“拷贝构造函数”的概念，在三种情况下，自动调用它
用一个对象初始化另一对象
对象作实参进行函数调用
对象作函数的返回值

通常，当一个对象需要做“深拷贝”(钱能：《C++程序设计教程》)时，我们需要为它事先定义“拷贝构造函数”、“赋值运算符的重载函数”和“析构函数”；否则编译器将以“按位copy”的形式自动生成相应的缺省函数。倘若类中含有指针成员或引用成员，那么这三个默认的函数就隐含了错误

Java则没有这种语法结构和语义逻辑
C++支持inline函数，可以避免函数的堆栈调用，提高运行效率

Java无这种语义

C++中，构造函数的初始化列表是这样使用的：首先按继承顺序调用基类的构造函数构造基类对象，然后按声明顺序调用成员对象的构造函数构造成员对象，最后对列表中出现的成员变量做初始化
Java不采用初始化列表这种构造机制
它们的构造顺序基本一致：
静态变量初始化
静态初始化块（Java）
调用基类的构造函数构造基类对象
实例变量的初始化
构造函数的其余部分
Java使用abstract关键字修饰抽象方法或抽象类

C++的对等语法是“纯虚函数”和“抽象类”

两者都使用抽象类作为继承层次中的基类，提供一般概念，由子类实现其抽象方法，且抽象类都不能被直接实例化为对象
Java中有final关键字，修饰类、方法或变量
final类不能被继承
final方法不能被子类覆盖
final变量就是常量

C++中没有这个关键字，常量可以使用const或#define定义
const还可以修饰成员函数，即“常成员函数”，当一个const成员函数修改成员数据，或调用非const成员函数时，编译器会报错
我们应将不修改成员数据的函数声明为const
Java和C++中的static关键字语法和语义基本相同

static成员变量又叫类变量，被类的所有对象共享
A::x (C++)：必须在类体外初始化
A.x (Java)：必须在类体内初始化
static成员方法又叫类方法，访问static变量
A::f( ) (C++)
A.f( ) (Java)
两者都有内部类和局部类的语法和语义

Java中没有友元函数和友元类的概念，严格支持封装，不允许外部方法访问类的私有成员
而C++支持friend关键字，允许外部方法访问类的私有成员，因此不是一种纯面向对象的编程语言
Java中类或interface可以用public修饰，也可以不修饰；而C++类不能修饰

三种访问权限的语义相同，语法略有差别

C++中还有继承权限修饰符，Java则没有
class A: protected B, public C (C++)
class A extends B (Java)
Java有super关键字，指代父类对象，通常被用于调用父类的构造方法或一般方法
C++则没有super关键字

两者都有this，指代当前对象

Java有package的概念，可以将类组织起来，便于打包和部署，也有利于类的安全。C++没有这个概念，一个类可以被任意类访问
Java applet可以被嵌入html文档中，然后由Web浏览器下载和执行
Java API有对网络通讯的特别支持

C++则无内置网络功能
C++程序员必须显式地实现动态内存管理，在析构函数中用delete运算符或free( )函数释放对象和其他动态分配的数据空间，否则会造成“内存泄露”

而在Java中，垃圾收集是自动的。当对象的最后一个引用变量被释放掉，这个对象就成为垃圾收集器的候选对象了
因此Java不支持析构函数
finalize( )方法主要被用来释放先前打开的非内存资源，如文件句柄
Java源代码被编译成字节码（.class文件），字节码是一种只有JVM才能识别的二进制低级代码，它与具体的处理器无关，要由安装在OS之上的JVM解释执行，转换成相应平台的机器码，因此Java是体系结构中立和跨平台的

而C++直接被编译成底层平台的二进制机器码，由CPU执行，是平台相关的

因此，当解释执行时，Java程序速度更慢
Java语言支持多线程，允许并发线程的同步与互斥操作
C++则没有这种内在机制 参考技术C (1) Java有垃圾回收机制，当然也就没有C++的析构函数。但是，可控制性和C++相比就差了一点，而且也不是说有了垃圾回收，就不会产生内存泄漏。由于相互引用等原因可能造成对象的生存周期过长，垃圾回收失效。对象内存的回收，个人认为应该是由程序员来掌握的事情。C++可以用auto_ptr,shared_ptr等智能指针来完成自动析构，当然前提是你要熟悉他们的实现机制和应用场合
(2) Java中所有的对象都是分配在堆上，在Java中只有句柄，也就是引用，没有指针。这样做有哪些好处呢? a)没有指针。在java中没有sizeof, 没有*。看看下面这些语句吧，感觉是不是很象。b) 避免了临时对象。在Java中所有的对象都是以句柄表示，函数参数传递，结果返回等都是以句柄形式。也就避免了C++中经常出现的局部指针局部引用问题, 对象参数拷贝赋值，切片等问题,提高了效率和可靠性。
String a = new String(“123”); // Java Code
std::string *a = new string(“123”); //c++ code
(c) 在Java中，包含关系只能由句柄表示。
(3) Java是单根继承体系，而C++可以有多重继承。java可以用interface来实现多重继承。来谈谈Java中的Object类，许多有趣的地方。
Clone方法，C++也可以实现，呵呵，”虚拟构造函数”，参见<<More Effective C++>>
Equals方法, 由于Java中对象只能由句柄表示，又没有C++操作符重载的能力，所以这个来比较等价对象。C++中我们可以重载”==”操作符来判断等价对象。
Finalize方法，呵呵，类似于析构函数，但是千万不要当成析构函数来用哦，这个方法何时调用不是你能把握的，取决于垃圾回收机制
hashCode方法， STL没有HashMap,HashTable等，但是java.util中有，所以…..
剩余的都是满足线程和同步的方法，跟C++没有可比性
(3) 在java中数组也是对象，所以当你下标越界的时候，会收到一个异常。而C++数组显然要比Java快点，因为他不检查index。
(4) 在java中，”123”这种字符串也是对象，而在C++中确是const char*, 最让人范错的是那个字符串结束符。但是java和c++对这种const char* 字符去有相同的优化，试试下面的代码：
String a = "123";
String b = "123";
if (a == b)

System.out.println("OK");

C++代码:
const char *p = "123";
const char *q = "123";
if ( q == p)

std::cout<<"OK"<<std::endl;

(5) Java中所有的对象方法都是virtual, 除了声明为final的方法。
(6) 没有操作符重载
(7) 语言级的序列化机制, C++也可以实现，呵呵，看看C++高手对话中的，那位用模板模式来实现序列化。
(8) 语言级的线程类极其配套互斥类等
(9) 语言级的异常体系。C++中的异常少的可怜，就STL中那几个,当然C++要的就是高效
(10) Java反射机制
哎，从反射机制就可以看出来，Java和C++根本就没有可比性嘛。 参考技术D Java中对内存的分配是动态的,它采用面向对象的机制,采用运算符new为每个对象分配内存空间,而且,实际内存还会随程序运行情况而改变.程序运行中,每个,
Java系统自动对内存进行扫描,对长期不用的空间作为”垃圾”进行收集,使得系统资源得到更充分地利用.按照这种机制,程序员不必关注内存管理问题,这使Java程序的编写变得简单明了,并且避免了了由于内存管理方面的差错而导致系统出问题.而C语言通过malloc()和free()这两个库函数来分别实现分配内在和释放内存空间的,C++语言中则通过运算符new和delete来分配和释放内存.在C和C++这仲机制中,程序员必须非常仔细地处理内存的使用问题.一方面,如果对己释放的内存再作释放或者对未曾分配的内存作释放,都会造成死机;而另一方面,如果对长期不用的或不再使用的内存不释放,则会浪费系统资源,甚至因此造成资源枯竭.
Java不在所有类之外定义全局变量,而是在某个类中定义一种公用静态的变量来完成全局变量的功能.
Java不用goto语句,而是用try-catch-finally异常处理语句来代替goto语句处理出错的功能.
Java不支持头文件,面C和C++语言中都用头文件来定义类的原型,全局变量,库函数等,这种采用头文件的结构使得系统的运行维护相当繁杂.
Java不支持宏定义,而是使用关键字final来定义常量,在C++中则采用宏定义来实现常量定义,这不得于程序的可读性.
Java对每种数据类型都分配固定长度.比如,在Java中,int类型总是32位的,而在C和C++中,对于不同的平台,同一个数据类型分配不同的字节数,同样是int类型,在PC机中为二字节即16位,而在VAX-11中,则为32位.这使得C语言造成不可移植性,而Java则具有跨平台性(平台无关性).
类型转换不同.在C和C++中,可通过指针进行任意的类型转换,常常带来不安全性,而在Java中,运行时系统对对象的处理要进行类型相容性检查,以防止不安全的转换.
结构和联合的处理.在C和C++中,结构和联合的所有成员均为公有,这就带来了安全性问题,而在Java中根本就不包含结构和联合,所有的内容都封装在类里面
Java不再使用指针.指针是C和C++中最灵活,也最容易产生错误的数据类型.由指针所进行的内存地址操作常会造成不可预知的错误,同时通过指针对某个内存地址进行显式类型转换后,可以访问一个C++中的私有成员,从而破坏安全性.而Java对指针进行完全地控制,程序员不能直接进行任何指针操作.

Java 和 C++ 在对象创建方面的主要区别是啥？

【中文标题】Java 和 C++ 在对象创建方面的主要区别是啥？

【英文标题】：What is the main difference in object creation between Java and C++?Java 和 C++ 在对象创建方面的主要区别是什么？

【发布时间】：2011-04-18 17:21:56

【问题描述】：

我正在准备 Java 考试，之前考试中的一个问题是：“Java 和 C++ 在对象创建方面的主要区别是什么？”

我想我知道对象创建的基础知识，例如如何调用构造函数以及 Java 中的初始化块做什么，以及当一个类的构造函数调用另一个尚未构造的类的方法时会发生什么，等等，但我找不到任何明显的东西。答案应该是一两句话，所以我认为Java中对整个对象创建过程的描述并不是他们的想法。

有什么想法吗？

【问题讨论】：

您可能会发现这个问题也很有用。 ***.com/questions/4405074/…

【参考方案1】：

Java 和 C++ 在对象创建方面的主要区别是什么？

与 Java 不同，C++ 中的对象也可以在堆栈上创建。

例如在 C++ 中你可以编写

Class obj; //object created on the stack

在Java中你可以写

Class obj; //obj is just a reference(not an object)
obj = new Class();// obj refers to the object

【讨论】：

我认为这是在对象创建之前发生的内存分配。真的算吗？

我不确定他们是否在询问内存分配，但另一方面，我不确定他们是否在询问内存分配。

我会将这个答案扩展到考虑放置新... C++ 允许在任何地方创建对象 - 自动在堆栈或堆上，甚至是您指定的内存位置。在 Java 上，这一切都由 JVM 完成……而且它总是在堆上。

@Deep-B：放置 new 是一种非常先进的技术。我不希望一个普通的 C++ 用户知道如何使用它，更不用说一个正在研究 C++ 和 Java 之间差异的学生了

【参考方案2】：

我会回答：C++ 允许在任何地方创建对象：在堆上、堆栈上、成员上。 Java 强制您在堆上分配对象，总是。

【讨论】：

同@Prasoon：分配发生在对象创建之前，所以这真的是要求的吗？

@Space：至少在 Java 中，如果不创建对象就不能进行内存分配（即使在 C++ 中，这两者通常会一起使用），所以我认为信息仍然适用。

嗯，与 C++ 不同，在 java 中您不能将分配与创建分开。

@Joachim：这条评论本身可能是对这个问题的一个很好的回答。

@Space_C0wb0y：我想说内存分配是对象创建的一部分，另一种艺术是初始化。

【参考方案3】：

除了堆/堆栈问题，我想说：C++ 构造函数有初始化列表，而 Java 使用赋值。详情请见http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.6。

【讨论】：

+1 这是“Java 到 C++ 迁移”经常无法理解的内容。

【参考方案4】：

在 Java 中，执行 Java 代码的 Java 虚拟机 (JVM)必须可能¹记录所有正在创建的对象（或者准确地说是对它们的引用），所以当不再引用对象时，分配给它们的内存可以在以后通过垃圾回收自动释放。

编辑：我不确定这是否可以归因于严格意义上的对象创建，但它肯定会在创建和分配给变量之间的某个时间发生，即使没有显式分配（当你创建一个对象而不分配它，JVM 必须在一段时间后自动释放它，因为没有更多的引用）。

在 C++ 中，只有在堆栈上创建的对象才会自动释放（当它们超出范围时），除非您使用某种机制来为您处理。

¹：取决于JVM的实现。

【讨论】：

这实际上是实现依赖。据我所知，大多数垃圾收集器都会从收集根中遍历对象图，而不是增加引用计数器。

【参考方案5】：

除了其他出色的答案之外，还有一件事非常重要，通常被忽略/忘记或误解（这解释了为什么我在下面详细说明过程）：

在 Java 中，方法是虚拟的，即使从构造函数调用时也是如此（这可能会导致错误） 在 C++ 中，虚拟方法在从构造函数调用时不是虚拟的（这可能会导致误解）

什么？

让我们想象一个带有虚拟方法 foo() 的 Base 类。 让我们想象一个从 Base 继承的 Derived 类，它重写了 foo() 方法

C++和Java的区别在于：

在 Java 中，从基类构造函数调用 foo() 将调用 Derived.foo() 在 C++ 中，从 Base 类构造函数调用 foo() 将调用 Base.foo()

为什么？

每种语言的“错误”是不同的：

在 Java 中，调用构造函数中的任何方法都可能导致细微的错误，因为被覆盖的虚拟方法可能会尝试访问在 Derived 类中声明/初始化的变量。

从概念上讲，构造函数的工作是使对象存在（这几乎不是普通的壮举）。在任何构造函数中，整个对象可能只是部分形成——您只能知道基类对象已被初始化，但您无法知道哪些类是从您那里继承的。然而，动态绑定的方法调用会“向前”或“向外”进入继承层次结构。它调用派生类中的方法。如果您在构造函数中执行此操作，您调用的方法可能会操纵尚未初始化的成员——这肯定会导致灾难。

布鲁斯·埃克尔，http://www.codeguru.com/java/tij/tij0082.shtml

在 C++ 中，必须记住 virtual 不会按预期工作，因为只会调用当前构造类的方法。原因是避免访问数据成员甚至是尚不存在的方法。

在基类构造期间，虚函数永远不会进入派生类。相反，该对象的行为就好像它是基本类型一样。通俗地说，在基类构造过程中，虚函数不是。

斯科特·迈耶斯，http://www.artima.com/cppsource/nevercall.html

【讨论】：

+1 我自己偶然发现的……我父母告诉我很多危险的事情，但从来没有告诉我那个，我不得不去看看在互联网上。

@Hemant & @Archimedix：感谢您的 cmets！该问题的作者确实在他的问题中提到了“虚拟事物”，但我猜这个问题足够狡猾/恶毒，以至于有一个完善的答案，包括描述、事实和来源，而不是仅限于问题中的半句话。我很高兴看到我的猜测没有错。

我真的不能说哪个答案最适合这个问题，所以我会接受这个答案，因为它目前的支持率最高。

【参考方案6】：

C++ 和 Java 中的构造函数之间有一个主要的设计区别。其他差异来自此设计决策。

主要区别在于JVM首先将所有成员初始化为零，然后再开始执行任何构造函数。在 C++ 中，成员初始化是构造函数的一部分。

结果是在执行基类构造函数期间，在 C++ 中派生类的成员尚未初始化！在 Java 中，它们已被零初始化。

因此，paercebal's answer 中解释的规则是，从构造函数调用的虚拟调用不能下降到派生类。否则可能会访问未初始化的成员。

【参考方案7】：

假设 c++ 在进行新调用时使用 alloc()，那么它们可能就是这样 寻找。 （我不懂C++，所以这里我可能会很错误）

Java 的内存模型会在需要时分配一块内存，并且对于它使用的每个新内存 这个预先分配的区域。这意味着 java 中的 new 只是将指针设置为 内存段并在 C++ 中新建时移动空闲指针（假设它在后台使用 malloc） 将导致系统调用。

这使得在 Java 中创建对象比使用 malloc 的语言更便宜； 至少在没有初始化发生时。

简而言之 - 在 Java 中创建对象很便宜 - 除非您创建大量对象，否则不要担心。