-
this的值是对象本身地址；*this 就是对象arr1 1、 Array ... return *this 相当于： Array arrX = arr1; arrX是一个新的对象。即返回的this指针为另一个临时对象 2、 Array& ... return *this 相当于： Array & arrX = arr1; 此时arrX是arr1的别名。 3、 Array* ... return this 相当于： Array* arrX = this; 此时arrX的值 是地址，且是指向arr1的。用->访问或者*p. 访问查看全部
-
为什么需要const成员函数？ 我们定义的类的成员函数中，常常有一些成员函数不改变类的数据成员，也就是说，这些函数是"只读"函数，而有一些函数要修改类数据成员的值。如果把不改变数据成员的函数都加上const关键字进行标识，显然，可提高程序的可读性。其实，它还能提高程序的可靠性，已定义成const的成员函数，一旦企图修改数据成员的值，则编译器按错误处理。 const成员函数和const对象 实际上，const成员函数还有另外一项作用，即常量对象相关。对于内置的数据类型，我们可以定义它们的常量，用户自定义的类也一样，可以定义它们的常量对象。例如，定义一个整型常量的方法为： const int i=1 ； 同样，也可以定义常量对象，假定有一个类classA，定义该类的常量对象的方法为： const classA a(2)； 这里，a是类classA的一个const对象，"2"传给它的构造函数参数。const对象的数据成员在对象生存期内不能改变。但是，如何保证该类的数据成员不被改变呢？ 为了确保const对象的数据成员不会被改变，在C++中，const对象只能调用const成员函数。如果一个成员函数实际上没有对数据成员作任何形式的修改，但是它没有被const关键字限定的，也不能被常量对象调用。查看全部
-
Coordinate * const pCoor = &coor1 : 这种方式定义的常指针“只能指向coor1，但可以调用coor1的不同的函数”；（拥有读写权限） const Coordinate *pCoor = &coor1 : 只能调用coor1的“常成员函数”。（只拥有读权限）查看全部
-
class Array { public: Array(); Array(const Array &arr); ~Array(); void setCount(int count); int getCount(); private: int m_iCount; }; #include"Array.h" #include <iostream> using namespace std; Array::Array() { cout << "Array" <<endl; } Array::Array(const Array &arr) { m_iCount = arr.m_iCount; cout <<"Array&" <<endl; } Array::~Array() { cout <<"~Array" <<endl; } void Array::setCount(int count) { m_iCount = count; } int Array::getCount() { return m_iCount; } #include <iostream> #include <stdlib.h> #include "Array.h" using namespace std; int main() { Array arr1; arr1.setCount(5); Array arr2(arr1); cout << "arr2.m_iCount="<<arr2.getCount() <<endl; system("pause"); return 0; }查看全部
-
常对象只能调用常成员函数，不能调用普通成员函数； =》普通成员函数可能具有写权限，修改常对象成员变量的值。 普通对象能够调用常成员函数，也能调用普通成员函数。 =》普通对象的读写权限较高。 常指针 & 常引用都只能调用对象的常成员函数。 =》正确。读写权限匹配。 一个对象可以有多个对象常引用。查看全部
-
对象成员：一个对象作为另外一个类的数据成员<br><br><br> 对象成员指针：一个对象的指针作为另外一个类的数据成员<br><br> 1.对象成员指针的定义： 类名 * 指针名 是指针而不是对象<br> 2.指针在32位编译器下占4个基本内存单元<br><br> 3.若存在对象成员指针1，2……。sizeof（指针1，指针2……）只计算各指针所占内存的总和，不计算对象成员所占内存<br> 对象成员指针如果在构造函数用 new 的方式从堆中申请内存实例化2个 Coordinate 对象，那这2个对象都是在堆中，而不在 Line 对象中，因为每个指针占 4 个内存单元，因此 sizeof（Line） 只占 8 个内存单元，销毁 Line 的时候，先销毁队中的内存，在释放 Line 本身的内存查看全部
-
demo.cpp
#include<iostream>
#include<stdlib.h>
#include<string>
#include"Line.h"
using namespace std;
/*对象成员
要求：
定义两个类：
坐标类:Coordinate
数据成员：m_iX和m_iY
成员函数：构造函数，析构函数，数据封装函数
线段类：Line
数据成员：点A m_coorA，点B m_coorB
成员函数：构造函数，析构函数，数据封装函数，信息打印函数*/
int main(void)
{
Line *p = new Line();
delete p;
p = NULL;
system("pause");
return 0;
}
Line.cpp
#include"Line.h"
#include<iostream>
using namespace std;
Line::Line()
{
cout << "Line" << endl;
}
Line::~Line()
{
cout << "~Line" << endl;
}
void Line::setA(int x, int y)
{
m_coorA.setX(x);
m_coorA.setY(y);
}
void Line::setB(int x, int y)
{
m_coorB.setX(x);
m_coorB.setY(y);
}
void Line::printInfo()
{
cout << "(" << m_coorA.getX() << m_coorA.getY() << ")" << endl;
cout << "(" << m_coorB.getX() << m_coorB.getY() << ")" << endl;
}
Line.h#include"Coordinate.h"
class Line
{
public:
Line();
~Line();
void setA(int x,int y);
void setB(int x,int y);
void printInfo();
private:
Coordinate m_coorA;
Coordinate m_coorB;
};
Coordinate.cpp
#include"Coordinate.h"
#include<iostream>
using namespace std;
Coordinate::Coordinate()
{
cout << "Coordinate()" << endl;
}
Coordinate::~Coordinate()
{
cout << "~Coordinate()" << endl;
}
void Coordinate::setX(int x)
{
m_iX = x;
}
int Coordinate::getX()
{
return m_iX;
}
void Coordinate::setY(int y)
{
m_iY = y;
}
int Coordinate::getY()
{
return m_iY;
}
Coordinate.h
class Coordinate
{
public:
Coordinate();
~Coordinate();
void setX(int x);
int getX();
void setY(int y);
int getY();
private:
int m_iX;
int m_iY;
};
查看全部 -
p[0]指向第一个元素；执行p++之后p[0]指向第2个了！！！<br>
2.释放内存时要注意指针 p 指回原来的位置。用delete释放数组内存时要注意此时的指针*p要指到该数组的第一个元素上。保证申请和释放的是同一段内存第二个循环第一次打印的是第三个元素因为指针经过p++到第三个元素了，所以得用p--
注意：在对象数组中，想要访问某个堆中的对象的成员属性时，p->m_ix=1；和p[0].m_ix=1效果是一样的，但是p[0]->m_ix=1这种用法是错误、以及注意 p++后 p[0] 前后的指向是不一样的
数组的头指针最好要保留，采用(p+1)->m_iX的方式访问，不会更改头指针
查看全部 -
This 表示对象的地址，可以访问到自身对象的数据成员 This 代表当前自身的对象，谁调用 Array 构造对象，然后 This 就代表那个对象取代那个对象，也就是 Array arr1； Array arr1；arr1.setLen（5）的时候，{this -> len = len} 中 this 就是代表了 arr1 对象，会取代 this ，而 this 其实是对象的地址，也就是指针，{this -> len = len} 就代表是 { arr1.len = len; },从而标记区别了数据成员和参数。查看全部
-
this的值是对象本身地址；*this 就是对象arr1 1、 Array ... return *this 相当于： Array arrX = arr1; arrX是一个新的对象。即返回的this指针为另一个临时对象 2、 Array& ... return *this 相当于： Array & arrX = arr1; 此时arrX是arr1的别名。 3、 Array* ... return this 相当于： Array* arrX = this; 此时arrX的值 是地址，且是指向arr1的。用->访问或者*p. 访问查看全部
-
（1）32位的编译环境，一个指针占4个字节，1一个字节就是一个基本的内存单元，1Byte = 8 bit,即一个内存单元里可以存储2的8次方不同情况的高低电平。<br> （2）因为Line这个类中有，两个对象成员指针，所以占了8个字节。<br> （3）sizeof()函数返回的是整数，单位为“字节”. （4）64位的是32位的两倍查看全部
-
你们都是看过源码写的还是自己写的，感觉自己写好难啊，写不出来5555555查看全部
-
对象成员指针 实例化 Line 的时候，先调用 Coordinate 构造函数，再调用 Line 构造函数，销毁的时候，先销毁堆中的对象即 Coordinate 对象，再销毁 Line 对象。跟对象成员有区别，对象成员会先销毁 Line 对象，再销毁内层的 Coordinate 对象。查看全部
-
老师，堆和栈的优劣势在哪里啊？栈命名对象后不用管，堆还要去释放内存，明显栈更有优势啊！！！那么堆命名存在的意义是什么呢？查看全部
-
对象成员：一个对象中包含其他对象 如：class Line{ public： Line（）； private： Coordinate m_coorA; Coordinate m_coorB; } 当实例化这样一个对象时，会先实例化m_coorA，再实例化m_coorB，最后实例化Line 对象消亡时，会先销毁Line，再m_coorB,最后m_coorA查看全部
举报