原文链接(点击原文链接获取更多学习干货):
http://blog.bools.cn/archives/1335
在之前学习当中,我们知道C语言是面向过程的,而C++是面向对象的。
C++面向对象的三大特性,封装、继承、多态。
在C++当中,一般用#include
示范:
#include
#define _CRT_SECURE_NO_WARNINGS
using namespace std;
int main()
{
cout << "我就试一试c++" << ",看看和C语言的区别" << endl;
system("pause");//堵塞功能
return 0;
}
"::"双冒号作用:双冒号作用域运算符,就是将变量或者运算符的作用域扩大,一般和namespace一块用。
namespace命名空间的主要用途是解决命名冲突问题,而namespace就是命名一个空间,或者我们理解为打开一个房间。而
using namespace std;
一般在命名在全局变量当中,就是打开std这个房间,因为打开这个房间,cout和endl才能用。
namespace schoolA
{
int number = 20;
char name[20] = "foda";
}
int main()
{
using namespace schoolA;
cout << number << endl << name << endl;
//cout << schoolA::number << endl << schoolB::name << endl;//或者在变量前声明哪个空间
}
namespace的基本使用,一般是用using namespace 空间名后,可以使用。
namespace的特点:
void schoolA::test()
{
cout << "schoolA的名字是:" << schoolA::name << endl;
}
namespace schoolA
{
int sumnumber = 2000;
char name[20] = "foda";
//void test(){cout << "schoolA的名字是:" << schoolA::name << endl;}//直接在namespace中定义函数
void test();
struct A{int number = 30;};//在namespace中直接定义结构体
struct A;
}
int main()
{
//using namespace schoolA;
schoolA::test();
cout << schoolA::sumnumber << endl << schoolB::name << endl;
cout << schoolB::classA::number << endl;
}
空间包含函数和结构体时,函数和结构体可以直接在定义中定义,函数可以在外部定义,结构体建议在内部定义,不过函数定义时要“::”双冒号是哪个空间的函数和结构体。
namespace schoolA
{
int number = 20;
char name[20] = "foda";
}
int main()
{
using namespace schoolA;
cout << number << endl << name << endl;
//cout << schoolA::number << endl << schoolB::name << endl;//或者在变量前声明哪个空间
}
namespace schoolB
{
int number = 40;
char name[20] = "zhongda";
namespace classA
{
int number = 34;
}
}
cout << schoolB::classA::number << endl;
namespace schoolB
{
int number = 40;
char name[20] = "zhongda";
namespace classA
{
int number = 34;
}
}
namespace schoolB
{
int level = 3;
}
同名的空间可以合并。
可以起别名
namespace schoolfoda = schoolA;
cout << "schoolfoda的名字是" << schoolfoda::name << endl;
这里需要注意:在使用多个房间后,需要标明是哪个房间
using schoolC::number;//声明
using namespace schoolC;//编译指令
用using声明的话,需要注意避免二义性问题
二义性就是写了using声明之后,但编译器又有就近原则
using schoolC::number;//声明
using namespace schoolC;//编译指令
cout << number << endl;
二义性会使编译出错
int a;
int a=10;//出错
全局变量只能定义一次。
定义函数时,被调用函数要表明参数,返回值等
int func(int a, int b)
{
return (a + b);
}
char* p=(char*)malloc(sizeof(char));
类型必须转换成同类型的
C++中的struct可以添加函数成员
struct classA
{
int func(int a, int b)
{
return (a + b);
}
int number = 20;
};
而且使用的时候可以不加struct关键字
classA one;
bool类型只有真假,非0就是真,0为假,非0的值转为一。
bool flage=true;//1
在C语言当中,三目运算符返回的是一个值,而C++当中返回的是一个变量。
int a = 20;
int b = 30;
cout << b << endl;//30
a > b ? a : b = 50;
cout << b << endl;//50
在C语言中,const修饰的是伪常量,而在C++中,const修饰的真常量,不可改变的,和#define有异曲同工之妙,所以,建议在后面的代码编译中,定义宏定义常量时,建议用const
const int c = 40;
int* p = (int*)&c;
*p = 50;
cout << *p << endl << c << endl;
const在C语言中是外部链接,C++中默认const是内部链接
就是说, const定义的变量在同一项目其他文件中,能用,C++中const只能在本文件中用
const int c = 40;
int* p = (int*)&c;//会分配临时内存
const int c = 40;
int* p = (int*)&c;
*p = 50;
cout << *p << endl << c << endl;
const classA two;
classA* pp = (classA*)&two;//自定义类型的变量,取地址之后会分配内存
pp->score = 89;
cout << "classA的分数是:" << pp->score << endl;
引用就是取别名
int a=20;
int &b=a;
a的别名就是b。
int a=20;
int &b;//error
int &b=a;
int arr[10];
int(&parr)[10]=arr;
for(int i=0;i<10;i++)
{
cout<
引用必须引用一块合法的内存空间
不要返回局部变量的引用
引用其实也会取到地址,所以用引用来当函数参数的话,会改变实参
void swap1(int& a, int& b)
{
int temp=a;
a = b;
b = temp;
}
int main()
{
int a = 20;
int b = 30;
swap1(a, b);
cout << a <<" "<< b << endl;
int c = 10, d = 40;
swap1(c, d);
cout << c <<" " << d << endl;
}
引用做返回值时,函数可以直接当成变量
int& try1()
{
int e = 20;
return e;//那么e和try1()同名
}
int main()
{
int& ret = try1();//
cout << ret << endl;//20
cout << ret << endl;//乱码
}
想要多次使用引用的返回值,要将e设置成静态变量
int& try1()
{
static int e = 20;
return e;//那么e和try1()同名
}
int main()
{
int& ret = try1();
cout << ret << endl;
cout << ret << endl;
try1()=2000;//相当于e=2000;
cout << try() << endl;//2000
}
一般来说,引用必须要有合法的空间,所以,不能等于常量,不过,const可以让引用等于常量
int& arr=10;//int* const arr=10'//error
const int& arr = 10;//原理是int tmp=10;int* const arr=&tmp;
int* p = (int*)arr;
*p = 1000;//error
cout << arr << endl;
经过const修饰的引用,一般当成常量来用,不会被改变,而在调用函数时,想要展示而不想改变实参的话,可以将函数参数用const修饰
void swap1(const int& a, const int& b)
{
int temp=a;
a = b;//const修饰后,a和b不可修改
b = temp;
}