1.匿名对象:匿名对象是指创建对象时,只有创建对象的语句,却没有把对象地址值赋值给某个变量。
2.匿名对象的特点:
1、创建匿名对象直接使用,没有变量名。
new Person().eat() //eat方法被一个没有名字的Person对象调用了。
2、匿名对象在没有指定其引用变量时,只能使用一次。
new Person().eat(); 创建一个匿名对象,调用eat方法
new Person().eat(); 想再次调用eat方法,重新创建了一个匿名对象
3、匿名对象可以作为方法接收的参数、方法返回值使用
class Soultion
{
public:
Soultion()
{
cout << "Soultion()" << endl;
}
int Sum_Soultion(int n)
{
//...
cout << "Sum_Soultion()" << endl;
return 0;
}
~Soultion()
{
cout << "~Soultion()" << endl;
}
};
int main()
{
Soultion a1;//a1的声明周期在main函数中
a1.Sum_Soultion(10);
//Soultion();//匿名对象,声明周期就在这一行
Soultion() .Sum_Soultion(10);//只有我这一行会使用这个创建对象,别人不需要使用
return 0;
}
3.全局变量,静态变量,成员变量,析构和构造的顺序(和它们存储的区域有关)
class A
{
public:
A()
{
cout << "A()" << endl;
}
~A()
{
cout << "~A()" << endl;
}
};
class B
{
public:
B()
{
cout << "B()" << endl;
}
~B()
{
cout << "~B()" << endl;
}
};
class C
{
public:
C()
{
cout << "C()" << endl;
}
~C()
{
cout << "~C()" << endl;
}
};
class D
{
public:
D()
{
cout << "D()" << endl;
}
~D()
{
cout << "~D()" << endl;
}
};
C c;//全局变量
int main()
{
A a;
B b;
static D d;//静态变量
return 0;
}
//构造顺序: C A B D
//析构顺序:~B ~A ~D ~C
4.考点:计算下段程序进行了多少次拷贝构造(一共有7次拷贝构造)
class Widget
{
public:
Widget()
{}
Widget(const Widget & w)
{
cout << "Widget(const Widget&w)" << endl;
}
};
Widget f(Widget u)//1
{
Widget v(u);//2 4和5会被合二为一,优化掉成一个对象
Widget w = v;//3 在一个连续的动作中,连续的拷贝构造
return w;//4,8 都会被优化成一个拷贝
} 优化都发生返回和传参时,第8和第9被合二为一
int main()
{
Widget x;
//f(x);
Widget y = f(f(x));//5,6,7,9
//一共有7次拷贝构造
return 0;
}
5.C/C++内存分布
int globalVar = 1;//main函数之前就初始化,在哪都能用,作用域是全局的,这两个全局变量有什么区别呢?
链接属性不一样,globalVar所有文件中可见
static int staticVar = 1;//main函数之前就初始化,在哪都能用,作用域是全局的,只在当前文件可见
void Test()
{
static int staticVar = 1;//运行到这里再初始化,它的作用域在Test函数中,只能在Test函数中使用
int localVar = 1;
int n = 4;
int num1[10] = { 1,2,3,4,5,6,7,8,9,10 };
char char2[] = "abcd";//char2是一个栈上的数组
const char* pChar3 = "abcd";
int* ptr1 = (int*)malloc(sizeof (int*)*n);
int* ptr2 = (int*)calloc(4,sizeof(int));
int* ptr3 = (int*)realloc(ptr2,sizeof(int*)*n);
free(ptr1);
free(ptr3);
}
6.C语言动态内存管理:
考点:malloc/calloc/realloc的区别:
void Test()
{
int* p1 = (int*)malloc(sizeof(int));
free(p1);
//1.malloc/calloc/realloc的区别是什么
int* p2 = (int*)calloc(4, sizeof(int));
int* p3 = (int*)realloc(p2, sizeof(int)*10);
//这里需要free(p2)吗?
free(p3);
}
7.C++内存管理方式:
int main()
{
//C 本质上是malloc函数
int* p1 = (int*)malloc(sizeof(int));
int* p2 = (int*)malloc(sizeof(int)*10);
free(p1);
free(p2);
//C++ 本质上是操作符
//int* p3 = new int;
int* p3 = new int(10);//申请一个int4个字节空间,初始化成10
int* p4 = new int[10];//申请10个int的40个字节空间
delete p3;
delete[] p4;
return 0;
}
8.既然已经有了mallloc和free,new和delete的意义何在?
1.对于上面内置类型,他们的效果是一样的
2.对于自定义类型,是不一样的,malloc只申请空间,new 申请空间+构造函数初始化
free只释放空间,delete 析构函数+释放空间
9.全局的对象和全局的静态对象的析构顺序
class A
{
public:
A()
{
_a = 0;
cout << "A()" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
class B
{
public:
B()
{
_b = 0;
cout << "B()" << endl;
}
~B()
{
cout << "~B()" << endl;
}
private:
int _b;
};
//全局的对象和全局的静态对象差别是链接属性
//所以同一个文件中是跟定义的先后顺序有关,都是最后定义的先析构
//多个文件就不确定了
A a1;
B b1;
int main()
{
return 0;
}
10.内置类型和自定义类型不一样:
int main()
{
//内置类型和自定义类型不一样
int* p1 = new int;
int* p2 = (int*)malloc(sizeof(int));
A* p3 = (A*)malloc(sizeof(A));//只是申请空间
A* p4 = new A;//申请空间加构造函数初始化
free(p3);//释放空间
delete p4;//析构函数加释放空间
}