DotNet（171）
C/C++（225）
*JAVA（71）
创建对象：C++和Java的异同
C++
&&& Class User {...};
Class User {...}
对象构造：&&&&&&&&&&&&&& (1)
&&& User u(...);
对象构造：&&&&&&&&&&&&&& (2)
&&& User* p&= new User(...);
对象构造：
&&& User q = new User(...);
在标号为(1)的构造函数调用中，我们可以把u本身当作一个User对象。这个构造函数调用填充由u对象所占据的内存区域（栈空间），如下图(a)部分所示。
标号为(2)的构造函数调用创建了一小块内存区域（栈空间），其中存储了p的值(一个内存地址)，然后填充一个较大的内存区域（堆空间），赋值符右边所创建的User对象就存储在这块内存中。p所指向的内存地址就是User对象存储位置。如下图(b)部分所示
Java的构造函数调用也保留一个内存位置（栈空间）存储q的值，并填充一块内存（堆空间）保存User对象。在这种情况下，为q的值所保留的内存地址保存了User对象引用，如下图(C)部分所示。
JAVA创建对象和C# 创建对象一样
我们可以把q中存储的对象引用看成是一个伪指针(一个内存伪地址)，之所以说它是伪指针，是因为我们不能像C++指针那样对它进行解引用。如果由于内存管理的需要，JVM决定把这个User对象移动到内存中的一个不同位置，q所保存的对象引用仍然能够找到这个对象。反之，如果p所指向的对象转移到内存中的不同位置，那么p的值需要在程序的控制下进行显示的修改
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：446853次
积分：6107
积分：6107
排名：第3154名
原创：71篇
转载：732篇
评论：25条
(61)(58)(17)(18)(41)(21)(6)(3)(22)(29)(22)(35)(46)(9)(15)(19)(22)(87)(11)(22)(17)(14)(2)(12)(1)(6)(15)(49)(34)(27)(29)(11)(24)(10)(2)查看:2107|回复：4
助理工程师
以下代码是可以正常运行的
class Base
& & void print()
& && &&&printf(&print :Base!\n&);
int main()
& & Base* b=NULL;
& & b-&print();
& &return 0;
没有创建类对象，却可以调用类的不包含成员变量的成员函数。学校论坛上有人的解释是“编译器实际上是把所有的类成员函数改名(name mangling)并加上一个本类的this指针，使其非成员化。所以，在程序开始运行时，所有成员函数代码的地址已经确定，所有类对象共享， 而不像成员变量（非static）必须在实例化后才分配内存并且每个实例都拥有一份。”
但是我疑惑的是，为什么C++作为面向对象语言可以不创建对象就访问一个属于类的方法？这样做有什么好处？一个类方法虽然没有使用到类属性，但也应该是类行为，应该是这类对象才能够具备的，为什么可以随便调用？
至少在Java里面
& & b-&print(); //error,need Base b=new Base();
这样是错误的，必须创建对象。
助理工程师
1. 楼主求知精神值得学习
2. 给你解释的人说的基本上是正确的。
成员函数编译以后就是普通的函数，
比如Base的Print被改名为void Print_Base_xxxxx(Base* pBase)；
那b-&Print被转为Print_Base_xxxxx(NULL);
其实更激烈点的方式，比如Derived继承于Base，它实现了Print这个函数。
你在main里面调用
Derived* pDerived ＝ NULL;
pDerived-&P
再做一个假设，你想crack这个编译后的可执行程序。
你找个反汇编工具，看到函数调用call ptr[derived_print_xxx]类似这样一条语句，把它改为call ptr[base_print_xxx].再运行程序，你会发现调用的是Base的Print。
所以说成员函数和普通的非成员函数没有本质的区别（起码编译以后是这样），调用的方法也是一样的。
3. 编译器实现问题楼主不必深究。如果有兴趣你可以去windws mobile资源区看看ansi c++ standard，看看里面有没有对这个的实现做出具体的规定。如果c++ standard没有具体规定，那么不同的c++厂商怎么实现自己定。
助理工程师
多谢楼上。。。不过暂时还没有精力这么深入的研究，不过我会看的
助理工程师
嗯，多谢V哥，代码的实现问题基本理解，“所以说成员函数和普通的非成员函数没有本质的区别（起码编译以后是这样），调用的方法也是一样的。”
我只是想问，为什么C++要设计成这样，我觉得从面向对象概念上来讲，成员函数就应该和普通函数区分开来，一个类方法虽然没有使用到类属性，但也应该是类行为，应该是这类对象才能够具备的，为什么可以随便调用？
C++这么做有什么好处？
也许我钻牛角尖了，C++就是这么设计的，我也没啥办法。。。
初级工程师
成员函数与成员变量不同。成员函数，不需要反复的去声明、定义，可以节省好多空间。成员变量不能这么做，那是因为每个对象有所不同，当然，静态成员例外。
Copyright&
本论坛言论纯属发布者个人意见，不代表51CTO网站立场！如有疑义，请与管理员联系：C++创建对象，new与不new的区别 - 博客频道 - CSDN.NET
机器学习、机器视觉...
分类：C-C++
class MyClass {
MyClass(){
std::cout&&"MyClass is being created!"&&std::
~MyClass(){
std::cout&&"MyClass is being deleted!"&&std::
不用new创建对象
MyClass myclass = MyClass();
是存储在栈内存中，作用域结束后就会被释放。
优点：不用担心内存泄漏，系统会自动完成内存的释放。
缺点：函数中不能返回该对象的指针，因为函数结束后，该对象的内存就被释放了。
用new创建对象
MyClass* myclass = new MyClass();
是存储在堆内存中，作用域结束后不会被释放。除非进程结束或显示调用delete释放。
优点：函数中可以放回对象的指针，因为对象在函数结束后不会被释放。
缺点：如果管理不当，不delete的话，容易造成内存泄漏。
我看一些老外的程序，大多都是实用new，所以我以后也尽量使用new吧。
在java中的垃圾回收机制更方便，全部使用new，当没有这个对象引用的时候才会自动回收内存，不用担心内存泄漏。
总而言之: 无论c++还是java，都用new的方式创建对象，c++中要注意delete以免内存泄漏，java中不用担心。
autoliuweijie
排名：千里之外
（4）（21）（17）（22）（5）（11）（10）（6）（7）（9）（2）（4）（5）（2）
友情链接：Java对象和类
Java对象和类
Windows10用户联盟QQ群：
Java是一种面向对象的语言。由于具有面向对象特性的语言，Java支持以下基本概念：
在本章中，我们将探讨类和对象这些概念。
对象 -&对象具有状态和行为。例如：狗有状态 - 颜色，名称，繁殖以及行为，摇头晃脑，吠叫，吃。对象是类的实例。
类 -&一个类可以被定义为描述行为的模板/蓝色印花/指出其类型支持的对象。
Java对象：
现在，我们深入研究什么是对象。如果考虑到现实世界中，可以发现身边很多对象，汽车，狗，人等，这些对象都有一个状态和行为。
如果我们考虑一只狗，那么它的状态是 - 名称，品种，颜色和行为 - 吠叫，摇摆，跑等
如果软件对象与现实世界中的对象进行比较，它们具有非常相似的特征。
软件对象也有状态和行为。软件对象的状态存储在字段和行为是通过方法如图所示。
因此，在软件开发中，方法上的一个对象的内部状态和操作的对象对对象的通信是通过方法来完成。
Java中的类：
类是从中创建单个对象的蓝图。
类的样本如下︰
public class Dog{
String breed;
String color;
void barking(){
void hungry(){
void sleeping(){
一个类可以包含以下任意变量类型。
局部变量: &方法里面，构造函数或块中定义的变量称为局部变量。该变量将被声明和初始化的方法中，当该方法完成该变量将被销毁。
实例变量:&实例变量都在一个类，但任何方法之外的变量。这些变量在类被加载的实例化。实例变量可以从内部的任何方法，构造函数或特定类别的块访问。
类变量:&类变量是在一个类中声明，任何方法之外的变量，用static关键字。
类可以有任意数量的方法来访问各种方法的值。在上面的例子中，barking(), hungry() 和 sleeping()的方法。
以下提到的一些在Java语言中需要寻找到类要讨论的重要议题。
构造函数：
在讨论关于类，其中最重要分课题之一是构造函数。每个类都有一个构造函数。如果我们不明确地写一个构造函数的类，Java编译器生成一个默认构造函数的类。
创建一个新的对象中的每个时间，至少有一个构造函数将被调用。构造函数的主要规则是，他们应该具有相同的名称作为类。一个类可以有多个构造函数。
构造函数的例子如下︰
public class Puppy{
public Puppy(){
public Puppy(String name){
// This constructor has one parameter, name.
Java还支持，在这里能够创建的类只有一个实例。
创建对象：
如前面提到的，一个类提供的图纸对象。所以基本上一个对象是从一个类创建的。在Java中，关键字 new 用于创建新的对象。
从类创建对象时有三个步骤：
声明: &变量声明，一个变量名的对象类型。
实例:&&new&关键字是用来创建对象。
初始化: &关键字 new 后跟调用一个构造函数。这个调用初始化新的对象。
创建对象的实例在下面给出：
public class Puppy{
public Puppy(String name){
// This constructor has one parameter, name.
System.out.println(&Passed Name is :& + name );
public static void main(String []args){
// Following statement would create an object myPuppy
Puppy myPuppy = new Puppy( &tommy& );
如果我们编译并运行上面的程序，那么这将产生以下结果：
Passed Name is :tommy
访问实例变量和方法：
实例变量和方法是通过创建的对象的访问。要访问一个实例变量的完全限定路径应该如下：
/* First create an object */
ObjectReference = new Constructor();
/* Now call a variable as follows */
ObjectReference.variableName;
/* Now you can call a class method as follows */
ObjectReference.MethodName();
这个例子说明了如何访问一个类的实例变量和方法：
public class Puppy{
int puppyAge;
public Puppy(String name){
// This constructor has one parameter, name.
System.out.println(&Passed Name is :& + name );
public void setAge( int age ){
puppyAge = age;
public int getAge( ){
System.out.println(&Puppy's age is :& + puppyAge );
return puppyAge;
public static void main(String []args){
/* Object creation */
Puppy myPuppy = new Puppy( &tommy& );
/* Call class method to set puppy's age */
myPuppy.setAge( 2 );
/* Call another class method to get puppy's age */
myPuppy.getAge( );
/* You can access instance variable as follows as well */
System.out.println(&Variable Value :& + myPuppy.puppyAge );
如果我们编译并运行上面的程序，那么这将产生以下结果：
Passed Name is :tommy
Puppy's age is :2
Variable Value :2
源文件中声明的规则：
正如本节的最后部分现在让我们看看到源文件中声明的规则。声明类，import语句和包声明在源文件时，这些规则是必不可少的。
只能有一个有public类在每一个源文件。
源文件可以有多个非公共类。
公共类名应该是源文件，以及应当由 .java 在末尾附加的名称。例如：类名是 public class&Employee{} 将源文件应为&Employee.java。
如果类在包中定义，那么 package 语句应该是在源文件中的第一条语句。
如果&import&语句都存在，那么它们必须写&package&语句和类声明之间。如果没有包（package）语句，那么import语句应该是源文件中的第一行。
导入和包语句将意味着对所有现有的源文件中的类。不可能的声明不同的 import和/或包语句不同类的源文件中。
类有几个访问级别，有不同类型的类，抽象类，final类等将在访问修饰符章解释这些。
除了上述类型的类，Java也有一些特殊的类称为内部类和匿名类。
简单地，它是分类的类和接口的方式。在开发Java应用程序中，数以百计的类和接口将会被写入，因此，分类这些类是必须的。
import语句：
在Java中，如果一个完全合格的名称，其中包括包和类名，变量的话，编译器可以很容易地找到源代码或类。 import语句是给予适当的位置，是编译器发现，特定的类的方法。
例如，下面的行会要求编译器来加载所有目录中 java安装/java/io&可用的类：
import java.io.*;
一个简单的案例：
对于研究案例，这里将创建两个类。他们是 Employee 和 EmployeeTest。
首先打开记事本，并添加下面的代码。请记住，这是Employee类和类是一个公共类。现在，保存名称为 Employee.java 这个源文件。
Employee类有四个实例变量的名字，年龄，名称和工资。这个类有一个明确定义的构造函数，它接受一个参数。
import java.io.*;
public class Employee{
String name;
String designation;
double salary;
// This is the constructor of the class Employee
public Employee(String name){
this.name = name;
// Assign the age of the Employee
to the variable age.
public void empAge(int empAge){
/* Assign the designation to the variable designation.*/
public void empDesignation(String empDesig){
designation = empDesig;
/* Assign the salary to the variable salary.*/
public void empSalary(double empSalary){
salary = empSalary;
/* Print the Employee details */
public void printEmployee(){
System.out.println(&Name:&+ name );
System.out.println(&Age:& + age );
System.out.println(&Designation:& + designation );
System.out.println(&Salary:& + salary);
正如先前在本教程中所提到的，从处理的 main 方法开始。因此，为了让我们运行这个Employee类中应该有 main&方法，并应创建的对象。我们将创建这些任务一个单独的类。
下面给出的是 EmployeeTest&类，它创建 Employee类的两个实例，并调用方法为每个对象的每个变量赋值。
下面的代码保存在 EmployeeTest.java 文件
import java.io.*;
public class EmployeeTest{
public static void main(String args[]){
/* Create two objects using constructor */
Employee empOne = new Employee(&James Smith&);
Employee empTwo = new Employee(&Mary Anne&);
// Invoking methods for each object created
empOne.empAge(26);
empOne.empDesignation(&Senior Software Engineer&);
empOne.empSalary(1000);
empOne.printEmployee();
empTwo.empAge(21);
empTwo.empDesignation(&Software Engineer&);
empTwo.empSalary(500);
empTwo.printEmployee();
现在，编译这两个类，然后运行EmployeeTest看到的结果如下：
C :& javac Employee.java
C :& vi EmployeeTest.java
C :& javac
EmployeeTest.java
C :& java EmployeeTest
Name:James Smith
Designation:Senior Software Engineer
Salary:1000.0
Name:Mary Anne
Designation:Software Engineer
Salary:500.0
下一小节将讨论Java的基本数据类型，以及如何开发Java应用程序时使用它们。
标签：&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&