申请堆内存:
放一个int型变量int *p=new int; (在C语言中int *p=(int *)malloc(sizeof(int))) delete p;
放一个int型10元素的数组int *p=new int[10]; delete []p;
放一个结构体:
struct s
{
int n;
char str[20];
}
s *p=new s;申请一个结构体的内存
s *p=new s[10];申请结构体数组的内存
p[0].n=1;给第一个结构体实例化
strcpy(p[0].str,aa);
inline函数:
编译器把inline函数当成define宏定义处理,但前提是inline函数很简单,只有形式参数没有变量。若在很复杂的函数前加inline,编译器还是当作普通的函数处理,要入栈。
类和结构体里面有成员函数和成员变量,对象的大小是成员变量的大小,没包括成员函数的大小。
缺省参数:
缺省参数要从后往前有。 int add(int a=0,int b,int c=0),这样就不可以
*************这样是错误,会提示函数不接受两个参数***************************
#include<stdio.h>
int add(int a,int b,int c)
{
return (a+b+c);
}
int main()
{
int k=add(1,2);
return 0;
}
*************这样是错误,会提示函数不接受两个参数***************************
*************这样是正确,c默认是0***************************
#include<stdio.h>
int add(int a,int b,int c=0)
{
return (a+b+c);
}
int main()
{
int k=add(1,2);
return 0;
}
*************这样是正确,c默认是0***************************
布尔型:
大小为一个字节,和char一样
#include<iostream>
using namespace std;
大小为一个字节,和char一样
#include<iostream>
using namespace std;
int main()
{
cout<<sizeof(true)<<endl;
return 0;
}
{
cout<<sizeof(true)<<endl;
return 0;
}
引用型:
必须要挂在一个已有的变量上,地址相同,有任何一个变化另一个与变化
#include<iostream>
using namespace std;
必须要挂在一个已有的变量上,地址相同,有任何一个变化另一个与变化
#include<iostream>
using namespace std;
int main()
{
int k=8;
int& i=k;
return 0;
}
*******************c++引用实现两数交换*************
void swap(int& i,int& j)
{
int tmp=i;
i=j;
j=tmp;
}
int main()
{
int a=8;
int b=9;
swap(a,b);
return 0;
}
*******************c++引用实现两数交换*************
******************c语言指针实现两数交换****************
void swap(int *p,int *q)
{
int tmp=*p;
*p=*q;
*q=tmp;
}
int main()
{
int a=8;
int b=9;
swap(&a,& b);
return 0;
}
******************c语言指针实现两数交换****************
{
int k=8;
int& i=k;
return 0;
}
*******************c++引用实现两数交换*************
void swap(int& i,int& j)
{
int tmp=i;
i=j;
j=tmp;
}
int main()
{
int a=8;
int b=9;
swap(a,b);
return 0;
}
*******************c++引用实现两数交换*************
******************c语言指针实现两数交换****************
void swap(int *p,int *q)
{
int tmp=*p;
*p=*q;
*q=tmp;
}
int main()
{
int a=8;
int b=9;
swap(&a,& b);
return 0;
}
******************c语言指针实现两数交换****************
private权限:
private的成员变量只能由类的成员函数访问,出了类就不能对私有的成员变量,私有成员函数进行访问
private的成员变量只能由类的成员函数访问,出了类就不能对私有的成员变量,私有成员函数进行访问
this指针:
它代表的是现在被操作的对象的地址
0x24 0x30 0x3c两两相差12个字节
比如类里面的成员函数;
void SetData(int y,int m,int d)
{
year=y;
month=m;
day=d;
}
实质是这样写的:
void SetData(int y,int m,int d)
{
this->year=y;
this->month=m;
this->day=d;
}
它代表的是现在被操作的对象的地址
0x24 0x30 0x3c两两相差12个字节
比如类里面的成员函数;
void SetData(int y,int m,int d)
{
year=y;
month=m;
day=d;
}
实质是这样写的:
void SetData(int y,int m,int d)
{
this->year=y;
this->month=m;
this->day=d;
}
构造函数:
与类名同名,没有返回值类型,也不能写void。当对象一建立,构造函数就会被调用
******************没有传参的构造函数*******************
class SData
{
public:
SData()
{year=day=month=0;}
与类名同名,没有返回值类型,也不能写void。当对象一建立,构造函数就会被调用
******************没有传参的构造函数*******************
class SData
{
public:
SData()
{year=day=month=0;}
private:
int year;
int month;
int day;
}
int main()
{
SData s1,s2;当定义对象是,,里面的年月日就是0。。。。相当于初始化。
return 0;
}
******************没有传参的构造函数*******************
******************可以传参的构造函数*******************
class SData
{
public:
SData()
{year=day=month=0;}
SData(int y,int m,int d)
{year=y;
month=m;
day=d;}
int year;
int month;
int day;
}
int main()
{
SData s1,s2;当定义对象是,,里面的年月日就是0。。。。相当于初始化。
return 0;
}
******************没有传参的构造函数*******************
******************可以传参的构造函数*******************
class SData
{
public:
SData()
{year=day=month=0;}
SData(int y,int m,int d)
{year=y;
month=m;
day=d;}
private:
int year;
int month;
int day;
}
int main()
{
SData s1,s2;当定义对象是,,里面的年月日就是0。。。。相当于初始化。
SData s3(2011,1,1);
SData s4(s3);将原有的对象赋给新定义的对象,就是拷贝构造
return 0;
}
******************可以传参的构造函数*******************
一个类可以有多个构造函数,但只能有一个析构函数。
int year;
int month;
int day;
}
int main()
{
SData s1,s2;当定义对象是,,里面的年月日就是0。。。。相当于初始化。
SData s3(2011,1,1);
SData s4(s3);将原有的对象赋给新定义的对象,就是拷贝构造
return 0;
}
******************可以传参的构造函数*******************
一个类可以有多个构造函数,但只能有一个析构函数。