@Autowired无法自动注入 - ITeye问答
框架用的是springside4，基于springmvc的，我在我的service的实现类和DAO里面都加了@Component注解，在单元测试的时候可以自动注入，跑项目的时候就报空指针异常了。有没有遇到同样问题的朋友啊
问题补充：问题解决了，因为我引用自动注入的类本身不是spring管理的，给这个类加上@component注解其他spring组件就可以自动注入了
是不是没有扫描到相应的包啊。
如果是必须的对象，试试@Autowired进构造函数，个人感觉@Autowired进构造函数，比@Autowired变量声明要靠谱。
已解决问题
未解决问题3-Java面向对象-封装综合案例 - 送吗网
3-Java面向对象-封装综合案例
天涯明月笙 阅读:8
案例简介通过一个简单的案例具体的实现一下封装。通过java语言和面向对象的思想，模拟一个场景的实现。案例: 学校开设了计算机科学与应使用这个专业,专业编号: J0001;学制年限: 4年;现在有三个学生报名了该学校。实现的效果图:package cn.mtianyan.public class Subject {
public Subject(String name, String code, int year){
this.setName(name);
this.setCode(code);
this.setYear(year);
public void showInfo(){
System.out.println("专业信息如下:");
System.out.println("专业名称: " + this.name);
System.out.println("专业编号: " + this.code);
System.out.println("学制年限: " + this.year +"年");
System.out.println("=====================");
public String getName() {
public void setName(String name) {
this.name =
public String getCode() {
public void setCode(String code) {
this.code =
public int getYear() {
public void setYear(int year) {
this.year =
private S}package cn.mtianyan.public class Student {
public Student(String name,String studentID, String sex,int age,Subject subject){
this.setName(name);
this.setStudentID(studentID);
this.setAge(age);
this.setSex(sex);
this.subject =
public void showInfo(){
System.out.println("==================");
System.out.println("姓名: "+name);
System.out.println("学号: "+studentID);
System.out.println("性别: "+sex);
System.out.println("年龄: "+age);
System.out.println("所报专业名称: "+ subject.getName());
System.out.println("学制年限: "+ subject.getYear());
public String getName() {
public void setName(String name) {
this.name =
public String getStudentID() {
return studentID;
public void setStudentID(String studentID) {
this.studentID = studentID;
public String getSex() {
public void setSex(String sex) {
this.sex =
public int getAge() {
public void setAge(int age) {
this.age =
private String studentID;
private S}package cn.mtianyan.public class Test {
public static void main(String[] args) {
Subject subject = new Subject("计算机科学与应使用","J0001",4);
subject.showInfo();
Student student1 = new Student("张三","S01","男",18, subject);
student1.showInfo();
Student student2 = new Student("李四","S02","女",17, subject);
student2.showInfo();
Student student3 = new Student("王五","S03","男",18, subject);
student3.showInfo();
}}运行结果:上面是我个人的实现.综合案例计算机科学与应使用是一个对象。 三个学生是三个对象。学科专业类 & 专业类类:专业: 专业名称、编号、学制年限学生: 姓名、学号、性别、年龄编写Subject类啊啊啊，英语真季二茶，Get到了。Subject是学科。分包存储: cn.mtianyan.model cn.mtianyan.testpackage cn.mtianyan./** * 专业类 * @author mtianyan */public class Subject {
// 成员属性：学科名称、学科编号、学制年限、报名选修的学生信息、报名选修的学生个数
private String subjectN
private String subjectNo;
private int subjectL
private Student[] myS // 专业学生数组
private int studentN
// 无参构造方法
public Subject() {
// 带参构造，带参构造，实现对一律属性的赋值
public Subject(String subjectName, String subjectNo, int subjectLife) {
// this.subjectName=subjectN
this.setSubjectName(subjectName);
this.setSubjectNo(subjectNo);
this.setSubjectLife(subjectLife);
public void setSubjectName(String subjectName) {
this.subjectName = subjectN
public String getSubjectName() {
return this.subjectN
public String getSubjectNo() {
return subjectNo;
public void setSubjectNo(String subjectNo) {
this.subjectNo = subjectNo;
public int getSubjectLife() {
return subjectL
// 设置学制年限，限制必需&0
public void setSubjectLife(int subjectLife) {
if (subjectLife &= 0)
this.subjectLife = subjectL
* 获取选修专业的学生信息 假如保存学生信息的数组未被初始化，则，先初始化长度200
* @return 保存学生信息的数组
public Student[] getMyStudents() {
if(this.myStudents==null)
this.myStudents=new Student[200];
return myS
public void setMyStudents(Student[] myStudents) {
this.myStudents = myS
public int getStudentNum() {
return studentN
public void setStudentNum(int studentNum) {
this.studentNum = studentN
* 专业详情的方法
* @return 专业详情的相关信息，包括名称、编号、年限
public String info() {
String str = "专业信息如下：\n专业名称：" + this.getSubjectName() + "\n专业编号：" + this.getSubjectNo() + "\n学制年限："
+ this.getSubjectLife() + "年";
public void addStudent(Student stu){
* 1、将学生保存到数组中
* 2、将学生个数保存到studentNum
//1、将学生保存到数组中
for(int i=0;i&this.getMyStudents().i++){
if(this.getMyStudents()[i]==null){
stu.setStudentSubject(this);
this.getMyStudents()[i]=
//2、将学生个数保存到studentNum
this.studentNum=i+1;
}}这里我们的info方法在设计的时候返回String而不是直接在方法内打印，表现了单一职责准则，这样的设计使得这些字符串假如后期不是在控制台打印，而是做其余解决更方便。编写Student类package cn.mtianyan.public class Student {
// 成员属性：学号、姓名、性别、年龄、专业
private String studentNo;
private String studentN
private String studentS
private int studentA
private Subject studentS
// 无参构造方法
public Student() {
//多参构造方法，实现对学号、姓名、性别、年龄的赋值
public Student(String studentNo, String studentName, String studentSex, int studentAge) {
this.setStudentNo(studentNo);
this.setStudentName(studentName);
this.setStudentSex(studentSex);
this.setStudentAge(studentAge);
// 多参构造方法，实现对一律属性的赋值
public Student(String studentNo, String studentName, String studentSex, int studentAge,Subject studentSubject) {
this.setStudentNo(studentNo);
this.setStudentName(studentName);
this.setStudentSex(studentSex);
this.setStudentAge(studentAge);
// this.studentAge=studentA
this.setStudentSubject(studentSubject);
public String getStudentNo() {
return studentNo;
public void setStudentNo(String studentNo) {
this.studentNo = studentNo;
public String getStudentName() {
return studentN
public void setStudentName(String studentName) {
this.studentName = studentN
public String getStudentSex() {
return studentS
public void setStudentSex(String studentSex) {
// 限制性别只能是“男”或者者“女”，反之，强制赋值为“男”
if(studentSex.equals("男") | studentSex.equals("女")){
this.studentSex = studentS
this.studentSex = "男";
public int getStudentAge() {
return studentA
* 给年龄赋值，限定必需在10--100之间，反之赋值为18
* @param studentAge
传入的年龄
public void setStudentAge(int studentAge) {
if (studentAge & 10 || studentAge & 100)
this.studentAge = 18;
this.studentAge = studentA
* 获取专业对象，假如没有实例化，先实例化后再返回
* @return 专业对象信息
public Subject getStudentSubject() {
if(this.studentSubject==null)
this.studentSubject=new Subject();
return studentS
public void setStudentSubject(Subject studentSubject) {
this.studentSubject = studentS
* 学生自我详情的方法
* @return 自我详情的信息，包括姓名、学号、性别、年龄
public String introduction() {
String str = "学生信息如下：\n姓名：" + this.getStudentName() + "\n学号：" + this.getStudentNo() + "\n性别："
+ this.getStudentSex() + "\n年龄：" + this.getStudentAge()+ "\n所报专业名称：" + this.getStudentSubject().getSubjectName() + "\n学制年限："
+ this.getStudentSubject().getSubjectLife();
* 学生自我详情的方法
* @param subjectName 所学专业名称
* @param subjectLife 学制年限
* @return 自我详情的信息，包括姓名、学号、性别、年龄、所学专业名称、学制年限
public String introduction(String subjectName, int subjectLife) {
String str = "学生信息如下：\n姓名：" + this.getStudentName() + "\n学号：" + this.getStudentNo() + "\n性别："
+ this.getStudentSex() + "\n年龄：" + this.getStudentAge() + "\n所报专业名称：" + subjectName + "\n学制年限："
+ subjectL
* 学生自我详情的方法
* @param mySubject 所选专业的对象
* @return自我详情的信息，包括姓名、学号、性别、年龄、所学专业名称、学制年限
public String introduction(Subject mySubject){
String str = "学生信息如下：\n姓名：" + this.getStudentName() + "\n学号：" + this.getStudentNo() + "\n性别："
+ this.getStudentSex() + "\n年龄：" + this.getStudentAge() + "\n所报专业名称：" + mySubject.getSubjectName() + "\n学制年限："
+ mySubject.getSubjectLife()+"\n专业编号："+mySubject.getSubjectNo();
}}对于参数很多的构造方法，可以选择右键生成构造方法，而后选择上所要涵盖的参数。如何实现字符串内容能否相等的判断?可以通过equals()方法进行字符串内容的判断,假如内容相等返回值为true，反之为false。如:当str代表使用户性别时,可以通过如下代码判断性别为男还是女if (str.equals("男"))
System.out.println("性别为男")else
System.out.println("性别为女")通过方法实现学生与专业关联方案1: 在方法中增加两个参数,分别表示专业名称和学制年限。
public String introduction(String subjectName, int subjectLife) {
String str = "学生信息如下：\n姓名：" + this.getStudentName() + "\n学号：" + this.getStudentNo() + "\n性别："
+ this.getStudentSex() + "\n年龄：" + this.getStudentAge() + "\n所报专业名称：" + subjectName + "\n学制年限："
+ subjectL
}前往 Editor -& General 中 Other 部分，选中 show quick documentation on mouse move 设置多少毫秒会显示。这样可以看到文档注释的优点所在。通过方法实现学生与专业关联-方案2这里我们增加的两个参数和我们Subject类中的属性造成了数据冗余。在方法中增加1个专业对象作为参数,通过其属性取得相关信息
* 学生自我详情的方法
* @param mySubject 所选专业的对象
* @return自我详情的信息，包括姓名、学号、性别、年龄、所学专业名称、学制年限
public String introduction(Subject mySubject){
String str = "学生信息如下：\n姓名：" + this.getStudentName() + "\n学号：" + this.getStudentNo() + "\n性别："
+ this.getStudentSex() + "\n年龄：" + this.getStudentAge() + "\n所报专业名称：" + mySubject.getSubjectName() + "\n学制年限："
+ mySubject.getSubjectLife()+"\n专业编号："+mySubject.getSubjectNo();
}通过方法实现学生与专业关联-方案3由于大学生是肯定有一个专业信息的，在类中增加专业对象作为成员属性,通过其属性取得相关信息。
private Subject studentS // 对象默认值是null
// 构造函数增加参数
// 添加set 和 get方法类除了我们需要使用到的有参构造，应该准备一个无参构造，保证程序特殊情况的正常运行。
public Subject getStudentSubject() {
if(this.studentSubject==null)
this.studentSubject=new Subject();
return studentS
}"\n学制年限："+ this.getStudentSubject().getSubjectLife();先获取到专业对象，再通过对象获取到专业年限通过方法实现学生与专业关联-方案分析方案1 :在方法中增加两个参数,分别表示专业名称和学制年限 优点: 容易了解 缺点: 参数列表长方案2 :在方法中增加1个专业对象作为参数,通过其属性取得相关信息。 优点: 更加简单 获取参数方便 学生与专业关联性不强方案3 ;在类中增加专业对象作为属性,通过其属性取得相关信息.
优点: 关联性更强方法中传入对象，传递的是一个对象的引使用。在方法中通过对象作为参数,传递的是它的引使用可以通过引使用获取该对象所有信息。这样是很不安全的。
public String introduction(Subject mySubject){
mySubject.setSubjectName("mtianyan学科");
String str = "学生信息如下：\n姓名：" + this.getStudentName() + "\n学号：" + this.getStudentNo() + "\n性别："
+ this.getStudentSex() + "\n年龄：" + this.getStudentAge() + "\n所报专业名称：" + mySubject.getSubjectName() + "\n学制年限："
+ mySubject.getSubjectLife()+"\n专业编号："+mySubject.getSubjectNo();
}Subject sub1=new Subject("计算机科学与应使用","J0001",4);Student stu3=new Student("S03","王五","男",18);System.out.println(stu3.introduction(sub1));System.out.println("=====================");System.out.println(sub1.info());可以看到学生类中的自我详情修改专业，会将sub1都修改掉。这里如何对于传入的对象进行保护，后面再讲。目前先记住这个问题。新添加需求及分析计算机科学与应使用专业有多少个学生进行了报名?如何实现？使用什么样的容器装学生？用数组来放学生，最后一个学生的下标加1就是学生人数。先修改我自己个人的垃圾版本代码以满足该需求
private Student[] myS
private int studentN
public int getStudentsNum() {
return studentsN
public void setStudentsNum(int studentsNum) {
this.studentsNum = studentsN
public Student[] getStudents() {
public void setStudents(Student[] students) {
this.students =
}增加两个成员变量，并为其生成get set方法。构造方法中增加数组和学生数量初始化内容。这里的studentsNum定义成static的类属性更好。
public Subject(String name, String code, int year){
this.setName(name);
this.setCode(code);
this.setYear(year);
this.studentsNum = 0;
this.students = new Student[100];
}编写学生报到或者叫做增加学生的方法:
public void addStudent(Student student){
int stuNum = this.getStudentsNum();
this.getStudents()[stuNum] =
this.setStudentsNum(++stuNum); //这里set的必需是前置加加
public void showStudents(){
int stuNum = this.getStudentsNum();
for (int i=0;i&stuNi++) {
System.out.println(this.name+"专业学生信息: ");
System.out.println(students[i].getName());
System.out.println("----------");
subject.addStudent(student1);
subject.showStudents();
System.out.println("----------");
System.out.println("已有"+subject.getStudentsNum()+"人报名！");运行结果:官方实现数组无论里面存放的是什么，它都是引使用类型。
private Student[] myS
private int studentN
public int getStudentNum() {
return studentN
public void setStudentNum(int studentNum) {
this.studentNum = studentN
public Student[] getMyStudents() {
if(this.myStudents==null)
this.myStudents=new Student[200];
return myS
public void setStudents(Student[] students) {
this.students =
}数组的容量和当前放置了多少元素的长度是两个不同的值。因而我们既要定义数组，又要定义当前使用了的长度，后面我们会学到集合，将这两步操作合二为一。
public void addStudent(Student stu){
* 1、将学生保存到数组中
* 2、将学生个数保存到studentNum
//1、将学生保存到数组中
for(int i=0;i&this.getMyStudents().i++){
if(this.getMyStudents()[i]==null){
stu.setStudentSubject(this);
this.getMyStudents()[i]=
//2、将学生个数保存到studentNum
this.studentNum=i+1;
}增加时遍历数组，寻觅到第一个为null的位置填入，我觉得是不如我的填入策略的。package cn.mtianyan.public class FloatTest {
private static float [] f = new float[2];
public static void main(String[] args) {
System.out.println("f[0]="+f[0]);
}}数组是对象，对象实例化之后都是有默认值的解析: 数组未实例化造成的空指针异常接下来我们针对案例实现中的两个常见问题进行一下讲解!测试将学生数组实例化操作注释后的运行
public Student[] getMyStudents() {//
if(this.myStudents==null)//
this.myStudents=new Student[200];
return myS
}Exception in thread "main" java.lang.NullPointerException
at cn.mtianyan.model.Subject.addStudent(Subject.java:92)
at cn.mtianyan.test.SchoolTest.main(SchoolTest.java:24)会报出空指针异常。方案一: 我在公告的时候就顺便进行初始化，或者者在构造函数进行该值的初始化。方案二: 使用到的时候再进行创立。这里方案一和方案二都是可行的。方案二在这个操作假如是一个耗时操作的时候更合适一点。08:38 提问
ssh老是报空指针异常大神帮忙看看
大概是这种情况，大神帮忙看看。
按赞数排序
main方法里调用了b.f()方法。b.f()方法里调用了a.methodai()方法，但此时a是一个null对象(你并没有生成一个a对象实例)，调用一个null对象的方法当然要报NullPointException异常了
B b=new B();
A a=new A();
b.setA(a);
public A a=new A();
class B第一行，声明class A的对象的时候要new一下，防止空指针
public A a
只是定义了一个A对象的变量,并没有创建一个A对象,你应该public A a =
你这个是因为A实例没有初始化，所以报nullPoint.你说的是ssh框架，看到别人的代码也是这样写，但在ssh中需要配置ApplicationContext.xml，通过控制反转通过setXXX()注册进去的，明显你这里并没有，所以你要写ApplicationContext()文件，还要就是要加载该文件才行
同意一楼的说法，你应该先创建一个类型为A的对象，然后使用setA()方法设置一下a的值，那么就不会报空指针了，然后才是你的创建B对象，调用b.f()
什么是类？什么是对象？我的天...
B里面加一个构造函数，让B初始化的时候，实例化一个a
在spring里没有配置
准确详细的回答，更有利于被提问者采纳，从而获得C币。复制、灌水、广告等回答会被删除，是时候展现真正的技术了！
其他相关推荐构造函数是干什么的
该类对象被创建时，编译系统对象分配内存空间，并自动调用该构造函数，由构造函数完成成员的初始化工作，故：构造函数的作用：初始化对象的数据成员。
构造函数的种类
1 class Complex
4 private :
// 无参数构造函数
// 如果创建一个类你没有写任何构造函数,则系统会自动生成默认的无参构造函数，函数为空，什么都不做
// 只要你写了一个下面的某一种构造函数，系统就不会再自动生成这样一个默认的构造函数，如果希望有一个这样的无参构造函数，则需要自己显示地写出来
Complex(void)
m_real = 0.0;
m_imag = 0.0;
// 一般构造函数（也称重载构造函数）
// 一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数，前提是参数的个数或者类型不同（基于c++的重载函数原理）
// 例如：你还可以写一个 Complex( int num)的构造函数出来
// 创建对象时根据传入的参数不同调用不同的构造函数
Complex(double real, double imag)
// 复制构造函数（也称为拷贝构造函数）
// 复制构造函数参数为类对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中
// 若没有显示的写复制构造函数，则系统会默认创建一个复制构造函数，但当类中有指针成员时，由系统默认创建该复制构造函数会存在风险，具体原因请查询有关 &浅拷贝& 、&深拷贝&的文章论述
Complex(const Complex & c)
// 将对象c中的数据成员值复制过来
m_real = c.m_
// 类型转换构造函数，根据一个指定的类型的对象创建一个本类的对象
// 例如：下面将根据一个double类型的对象创建了一个Complex对象
Complex::Complex(double r)
m_imag = 0.0;
// 等号运算符重载
// 注意，这个类似复制构造函数，将=右边的本类对象的值复制给等号左边的对象，它不属于构造函数，等号左右两边的对象必须已经被创建
// 若没有显示的写=运算符重载，则系统也会创建一个默认的=运算符重载，只做一些基本的拷贝工作
Complex &operator=(const Complex &rhs)
// 首先检测等号右边的是否就是左边的对象本，若是本对象本身,则直接返回
if ( this == &rhs )
return *this;
// 复制等号右边的成员到左边的对象中
this-&m_real = rhs.m_
this-&m_imag = rhs.m_
// 把等号左边的对象再次传出
// 目的是为了支持连等 eg:
a=b=c 系统首先运行 b=c
// 然后运行 a= ( b=c的返回值,这里应该是复制c值后的b对象)
return *this;
&下面使用上面定义的类对象来说明各个构造函数的用法：
1 void main()
// 调用了无参构造函数，数据成员初值被赋为0.0
Complex c1，c2;
// 调用一般构造函数，数据成员初值被赋为指定值
Complex c3(1.0,2.5);
// 也可以使用下面的形式
Complex c3 = Complex(1.0,2.5);
// 把c3的数据成员的值赋值给c1
// 由于c1已经事先被创建，故此处不会调用任何构造函数
// 只会调用 = 号运算符重载函数
// 调用类型转换构造函数
// 系统首先调用类型转换构造函数，将5.2创建为一个本类的临时对象，然后调用等号运算符重载，将该临时对象赋值给c1
// 调用拷贝构造函数( 有下面两种调用方式)
Complex c5(c2);
Complex c4 = c2;
// 注意和 = 运算符重载区分,这里等号左边的对象不是事先已经创建，故需要调用拷贝构造函数，参数为c2
参考：http://www.cnblogs.com/xkfz007/archive//2496447.html
复制构造函数
几个原则：
C++ primer p406 ：复制构造函数是一种特殊的构造函数，具有单个形参，该形参（常用const修饰）是对该类类型的引用。当定义一个新对象并用一个同类型的对象对它进行初始化时，将显示使用复制构造函数。当该类型的对象传递给函数或从函数返回该类型的对象时，将隐式调用复制构造函数。
C++支持两种初始化形式：复制初始化（int a = 5;）和直接初始化（int a(5);）对于其他类型没有什么区别，对于类类型直接初始化直接调用实参匹配的构造函数，复制初始化总是调用复制构造函数，也就是说：
A x(2);　　//直接初始化，调用构造函数
A y =　　//复制初始化，调用复制构造函数
必须定义复制构造函数的情况：
只包含类类型成员或内置类型（但不是指针类型）成员的类，无须显式地定义复制构造函数也可以复制；有的类有一个数据成员是指针，或者是有成员表示在构造函数中分配的其他资源，这两种情况下都必须定义复制构造函数。
什么情况使用复制构造函数：
类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：（1）一个对象以值传递的方式传入函数体 （2）一个对象以值传递的方式从函数返回 （3）一个对象需要通过另外一个对象进行初始化。
深拷贝和浅拷贝：
所谓浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。在&深拷贝&的情况下，对于对象中动态成员，就不能仅仅简单地赋值了，而应该重新动态分配空间
如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝
上面提到，如果没有自定义复制构造函数，则系统会创建默认的复制构造函数，但系统创建的默认复制构造函数只会执行&浅拷贝&，即将被拷贝对象的数据成员的值一一赋值给新创建的对象，若该类的数据成员中有指针成员，则会使得新的对象的指针所指向的地址与被拷贝对象的指针所指向的地址相同，delete该指针时则会导致两次重复delete而出错。下面是示例：
1 #include &iostream.h&
2 #include &string.h&
3 class Person
5 public :
// 构造函数
Person(char * pN)
cout && "一般构造函数被调用 !\n";
m_pName = new char[strlen(pN) + 1];
//在堆中开辟一个内存块存放pN所指的字符串
if(m_pName != NULL)
//如果m_pName不是空指针，则把形参指针pN所指的字符串复制给它
strcpy(m_pName ,pN);
// 系统创建的默认复制构造函数，只做位模式拷贝
Person(Person & p)
//使两个字符串指针指向同一地址位置
m_pName = p.m_pN
~Person( )
delete m_pN
32 private :
char * m_pN
36 void main( )
Person man("lujun");
Person woman(man);
// 结果导致
woman 的指针都指向了同一个地址
// 函数结束析构时
// 同一个地址被delete两次
48 // 下面自己设计复制构造函数，实现&深拷贝&，即不让指针指向同一地址，而是重新申请一块内存给新的对象的指针数据成员
49 Person(Person & chs);
// 用运算符new为新对象的指针数据成员分配空间
m_pName=new char[strlen(p.m_pName)+ 1];
if(m_pName)
// 复制内容
strcpy(m_pName ,chs.m_pName);
// 则新创建的对象的m_pName与原对象chs的m_pName不再指向同一地址了
重载赋值操作符：
通过定义operate=的函数，可以对赋值进行定义。像其他任何函数一样，操作符函数有一个返回值和形参表。形参表必须具有与该操作符操作数书目相同的形参（如果操作符是一个成员，则包括隐式this形参）。赋值是二元运算，所以该操作符函数有两个形参：第一个形参（隐含的this指针）对应着左操作数，第二个形参对应右操作数。
&一个应用了对赋值号重载的拷贝构造函数的例子：
1 #include &iostream&
3 using namespace
A(int);//构造函数
A(const A &);//拷贝构造函数
void print();
A &operator=(const A &);
16 A::A(int p)
point = new int;
22 A::A(const A &b)
cout&&"调用拷贝构造函数"&&
28 A::~A()
33 void A::print()
cout&&"Address:"&&point&&" value:"&&*point&&
38 A &A::operator=(const A &b)
if( this != &b)
point = new int;
*point = *b.
49 int main()
x.print();
y.print();
参见：C++拷贝构造函数详解：http://blog.csdn.net/lwbeyond/article/details/6202256
阅读(...) 评论()}