C++听课笔记重点

若有以下语句：
int a=8;
fun(a);//////此处调用函数2
const int b =4;
fun(b);////此处调用函数1
void fun(int &b)
{
cout<<"ggg"<<endl;
}
const int a = 9;
fun(a);////出错，无匹配
4，类型的转换：内在空间变小，高->低：例：double -> float
void fun(const int &a)////函数1
{
cout<<"lala"<<endl;
}
void fun(int &b)////函数2
{
cout<<"gggg"<<endl;
}
以上两函数属于重载。加const与不加，有区别
虚基表
自身空间
虚基类空间
例B T时，T对象的空间如下分布：
}
程序不报错，能正常运行。
柔性数组关键是指在结构体的定义过程中，最后一个数据成员为字符数组型时，可以不指定大小，其内存空间仍分配在结构体后面。但在使用过程中时，str处的数据长度不一。所以，相同结构体变量，不一定能相互赋值。
在C++中需要调用C中的函数时，必须使用exten "C" {}：
结构体内存对齐标准
结构体的内存对齐以最大的数据成员为标准
例：
struct A
{
double a;
int c;
}
sizeof(A) 值为16。对齐标准为double.
C++内联函数
只是在函数定义前的类型前加一个inline
例：inline int f(int x){return x*x;}
/////动态为str[]成员分配空间
p = (data *)malloc(sizeof(data)+strlen("hello soga\n")+1);
memcpy(p->str,q,sizeof(q));
strcpy(p->str,"hello soga\n");
puts(p->str);
{
public:
int a;
};
class B:virtual public A
{
int b;
};
int main()
{
cout<<sizeof(B)<<endl;
}
结果为：12
原因：派生类在继承虚基类时，会在内存首地址处插入一个虚基表，内存分布构建方式如下：
class B{
public:
A *a;/////正确，因为前面有对类A的声明
A &a;////正确
/* A a; *//// 错误，虽然前面有对类A的声明，但编译器无法知道A的空间大小，
//// 故无法分配空间，所以报错
};
在C++中类的关键字可用class，也可用struct，所以，类的实质上也是结构体，是对结构体的改进。类与结构体的区别很小。在C++中无结构体，都是class。
在C++中，结构体与类的区别：
结构体默认的属性是public
类默认的属性是private
例：
struct A
{
int a;
所有类定义的成员函数都是内联函数，类的内部没有内存的分配，只有声明
友员函数：
在类中声明，在类外定义
类的构造函数后的初值表的赋值顺序必须和数据成员的定义顺序相同
错误示例：
class A{
public :
int a;
int b;
A(int x,int y):b(x),a(b){//// 错误，是自右至左的方式执行，
在C++中没有float的常量
例：
void fun(float a)///函数1
{
cout<<a<<endl;
}
void fun(double b)////函数2
{
cout<<b<<endl;
}
fun(5.6);////此处调用函数2，常量5.6为double型
public:
Sample() {x=y=0;}
Sample(int a,int b) {x=a;y=b;}
~Sample()
{
if(x==y)
cout<<"x=y"<<endl;
else
cout<<"x!=y"<<endl;
}
void disp()
{
类中的常成员与常成员函数
常成员函数与普通成员函数的区别：常对象只能调用常成员函数，不能调用非常成员函数
普通对象可以调用常成员函数，但优先调用非常成员函数
所有类的成员函数都隐含了一个参数：类名 *this
例：类square中有个成员函数：getLength()
实际上的定义为：getLength(square *this)
extern "C"
{
void f(int num);
}
extern "C"
{
#include <pthread.h>
}
C++中的函数重载优先级的高低
1，const int最高
2，类型的精确匹配
3，类型的提升：内在空间变大，低数据类型->高数据类型，例：int -> float
3、高位的空位是以符号位作为填充，无符号型的符号位是0，所以此输出的高位为1.
4、溢出位会被截取
继承：
protected成员，在派生类中可访问
private 成员，在派生类中不能访问
在继承和派生中，没有重载关系，无论参数是否不同，一律被覆盖
要访问基类成员，可加上域作用符
void fun()
{
cout<<a<<endl;
}
};
int main()
{
A b;
b.a = 3;
b.fun();
return 0;
}
正确！
堆、栈、全局区、代码段
在C++中，如果自己定义了构造函数，系统将不再自动定义构造函数
在C++中malloc与new的区别：
}
A(const A &a)
{
cout<<"拷贝构造"<<endl;
}
~A()
{
cout<<"析构"<<endl;
}
}
////______________1________//
void fun(A x)
{
A t(x);
}
int main()
127 01111111 127
128 10000000
129 10000001 -1Байду номын сангаас7
推论：
1、数据在存入内存时，是直接放入变量内存的，即129被化为二进制后直接存入内存，故符号位被填充为了1，即负数标志位
2、数据取值时是以补码形式取出来，所以输出结果为-127
int main()
{
A a = 3;
return 0;
}
运行结果:
int构造 ////类似于2，类中有关于int的构造函数
析构
////______2__________//
#include<iostream.h>
class Sample
{
int x,y;
结构体中str的内存空间没有生成，但是其空间跟在结构体后面。
#include <stdio.h>
#include <string.h>
typedef struct DATA
{
int a;
char str[];
}data;
int main()
｛
data a,*p;
////______2__________//
void fun(A x)
{
}
int main()
{
fun(2);
return 0;
}
运行结果:
int构造 ////2传入fun，类中有关于int的构造函数
析构
////______2__________//
////______3__________//
数据存放：
数据在存入内存时，是直接放入变量内存的，但在取值时是以补码形式取出来
例：
char c = 129
printf("%d",d);
printf("%x",d);
输出结果：
-127
ffffff81