【C++】基础第一节C++与C的区别
一：QT软件简单使用
安装目录尽量不要有中文，新建工程也是。
第一个是运行，第二个是调试。在项目文件目录中有debug文件夹中有工程文件。
注意：新建工程时，选择non_QT project，选择c或者C++应用。
在源文件上面打开代码：
TEMPLATE = app
CONFIG += console//删除这行代码运行，之后撤销恢复这行代码就可以弹出运行显示窗口
CONFIG -= app_bundle
CONFIG -= qt
SOURCES += main.c参考或调试别人程序时，需要把工程目录中pro.user后缀文件删除编译器自动生成。
二：C与C++基本区别
C++适合开发软件c语言适合开发系统。
c++ 面向对象 C语言面向过程
c++比c效率差10%
三：命名空间使用方式
因为单词数太少，不同的人写的程序不可能所有的变量都没有重名现象，对于库来说，这个问题尤其严重，为了解决这个问题，引入了名字空间这个概念，通过使用 namespace xxx；你所使用的库函数或变量就是在该名字空间中定义的，这样一来就不会引起不必要的冲突了。
#include
//
namespace Name1//使用namespace定义一个命名空间
{
struct Student//里面结构体 变量a，b和add函数，嵌套的命名空间Name3都是命名空间Name1的成员
{
};
int a;
int add(int a, int b)
{
return a+b;//注意有返回值
}
namespace Name3
{
int a;//注意这个a和外面Name1的a不同，引用的时候要先进入Name1在进入Name3才可以用这个a
}
}
namespace Name2
{
int a;
}
//
// 1 用命名空间名+域解析符 ::引用成员
int main1()
{
Name1::a = 10;
Name1::Name3::a = 2;//嵌套引用
printf ("%d\n", Name1::add(Name1::Name3::a,5));//引用add函数要打开命名空间Name1
return 0;
}
//使用using声明一个命名空间
//using只对当前作用域有效离开这个函数还是需要用Name1::
int main2()
{
using namespace Name1;//声明后的空间 a前面不需要加Name1：：
a=10;
Name3::a=2;//由于Name3嵌套在Name1中，使用3中的a还是要Name3
printf("%d\n",add(Name3::a,5));
return 0;
}//注意不要同时声明有相同成员的命名空间，使用时候会不假前缀会冲突int a;使用默认命名空间
int main()
{
using namespace Name1;
Name1::a=10;
::a=2;当声明一个全局变量时，为了防止与其他命名空间冲突，可以使用：：a默认命名空间
printf("%d\n",add(::a,5));
}命名空间内部成员不一定写在一个函数‘里。8
可以
namespace name1（）
{
int a;
}
三C++中的输入输出
C++专属头文件
#include
c语言中 xxx.b->cxxx.b
stdio.h——》Cstdio.h
string.h——》Cstring.h
C ++中加c的拥有命名空间std
cout标准输出
cout是变量对应c中printf函数，与<<左移预算法结合成一个从右网住流动的数据流。
右边是字符串，左边是标准输出cout
std::endl换行
c中的转义字符在C++中同样可以使用。
std::cout << "hello world" << std::endl;
std::cout << "hello world\n";
using namespace std;//这样可以不用加std：：前缀
int a = 10;
char c = 'A';
double d = 1.2;
const char *str = "hello";
cout << "a = " << a << ", c = " << c << ", d = " << d << ",
str = " << str << endl;
printf ("a = %d, c = %c, d = %.1f, str = %s\n", a, c, d, str);;cout可以识别不同类型的数据类型的变量，不需要像printf写%d等
标准输入：cin scanf
int main()
{
int a;
char c;
double d;
char str[10];
scanf ("%d, %c, %lf, %s", &a, &c, &d, str);//在输入端要用逗号隔开才不会出错
// >> cin从右往左 输出，同样自动识别数据类型
// cin >> a >> c >> d >> str;
printf ("a = %d, c = %c, d = %.1f, str = %s\n", a, c, d, str);
// cin cout 都是放在最左边
// a << cin;
// hello >> cout;
return 0;
}寄存器变量：
#include
using namespace std;
//
int main1()
{
for (int i = 0; i < 10; i++)
cout << i << endl;//简单循环函数
return 0;
}
//
int main2()在c中不允许对寄存器变量使用取地址&，C++可以取地址，但取地址后不在寄存器变量
{
// a
register int a = 10;寄存器变量
// C++中对寄存器进行&操作，变量将放入内存中
printf("&a = %p\n", &a);
return 0;
新的数据类型bool,值为ture（非0不一定只有1） 和false（0）
int main4()
{
bool b=false;//b=0
std::cout<int main()
{
bool b = false;
// if (b == true) //
if (b)
{
}
demo3.cpp 2
// if ( b == false) //
if (!b)
{
}注意：不可将浮点变量用“==”或“！=”与任何数字比较。要留意，无论是float 还是double 类型的变量，都有精度限制。所以一定要避免将浮点变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。
float f = 0.0000000000000000000000001;
if (f < 0.000001 && f > -0.000001)
cout << "0" << endl;
else
cout << "!0" << endl;
float f1,f2;
if (f1 == f2)
{
}
if (f1 - f2 < 0.000001 && f1 - f2 > -0.000001)
{
cout << "f1 == f2" << endl;
}
return 0;
}三目运算符
#include
using namespace std;
int main1()
{
int a = 10;
int b = 20;
int c = a>b ? a : b;//在C中3目运算符不可以当左值的
cout << c << endl;
// C++中三目运算符返回的是空间
a>b ? a : b = 123; // *(a > b ? &a : &b) = 123;
printf ("a = %d, b = %d\n", a, b);//这里如果写成ab ? 10 : b = 123;
return 0;
}
// 函数的默认参数； 函数的形参可以设置默认值
int add(int a, int b = 10)
{
return a+b;
}
// 注意:
// 1、如果函数的某个形参使用了默认参数，则其右边的所有参数都要有默认参数（常数）
int func(int a, int b = 10, int c = 20)
{
}
// 2、函数的默认参数在函数声明和函数定义中只能有一个进行设置
int func1(int a, int b = 10); // 函数声明
int func1(int a, int b)//这边不能在对B赋值
{
cout << b << endl;
}
int main()
{
cout << add(1,2) << endl;
cout << add(1) << endl;
return 0;
}
函数的占位
#include
using namespace std;
// 函数的占位参数:只有类型，没有变量名的参数
int func(int a, int)
{
}
// 占位参数可以和默认参数一起使用
int func1(int a, int = 0)
{
}
int main()
{
func(1,2);//2不起作用但编译可以通过
func1(1);//只需要输入一个参数就行
return 0;
}
函数重载：
#include
using namespace std;
// 函数重载：允许写同名函数
void pitnt(int a)
{
printf ("%d\n", a);
}
void pitnt(int a, int b)
{
printf ("a = %d, b = %d\n", a, b);
}
void pitnt(int a, char c)
{
printf ("a = %d, c = %c\n", a, c);
}
// 重载的条件（任意一个）：
// 1、参数的个数不同
// 2、参数的类型不同
// 注意：
// 1、函数的返回值不能作为重载的条件
// 2、函数指向重载函数，要严格的匹配函数指针的类型
// 函数指针 类型
typedef void (*PFUNC)(int, int);返回值类型 ( * 指针变量名) ([形参列表]);
int main()
{
pitnt(1, 2);//对应第二个
pitnt(1);//对应第一个
pitnt(1,'A');//对应第三个
PFUNC f = pitnt;//将pitnt入口地址给函数指针f
f(1,2);
//f(1);
//f(1, 'A');划掉的2个是不可以的因为函数指针类型的型参必须有2个int类型数据
return 0;
}
C++语言中const与C的区别
#include
using namespace std;
void func()
{
#define SIZE 10//注意define宏定义后影响后面的所有程序，define前面的则不受影响
const int size = 10;
int a[size];
//#undef SIZE
}
// C++ const 修饰的内容 是一个常量不可以改变也不可以用指针
int main()
{
const int a = 10;
// 当对const 常量进行取地址的时候，编译会为其分配空间
// 但是const常量并不用
int *pa = (int*)&a;
*pa = 30;
printf ("pa = %p, &a = %p\n", pa, &a);//在c语言中a的值会改变的30，所以c语言const不是很安全，这里他们地址是一样的
// 在使用const常量的时候，是从符号表中取值，而不是内存中取值
printf ("*pa = %d, a = %d\n", *pa, a);
//cout << SIZE << endl;
//cout << size << endl;
return 0;
}
C++变量的引用
int a = 10;
int &b = a;
b = 20;
cout << a << endl;
类型 &别名 = 空间（变量名）
b 和 a 代表的是同一块空间，引用是给空间取个别名，本质上是一个常量指针
引用必须要进行初始化，引用目的是替代C语言中容易出现段错误的指针。
表达式中的取地址符&不再是取变量的地址，而是用来表示该变量是引用类型的变量。
在回调函数中可以这样使用：引用和指针一样都是在32位系统中4个字节
//int mySwap(int a, int b)
//{
// int tmp = a;
// a = b;
// b = tmp;
//}
注意：函数调用结束时，形参的空间和指针将会释放
int mySwap(int *pa, int *pb)//使用指针
{
int tmp = *pa;
*pa = *pb;
*pb = tmp;//这边不是改变指针的指向而且替换指向的内容
}
int mySwap(int &ra, int &rb)//使用引用给a和b所对应的空间取个别名
{
int tmp = ra;
ra = rb;
rb = tmp;
}
int main2()
{
int a = 10;
int b = 20;
mySwap(a, b);这边对应使用引用替换函数
printf ("a = %d, b = %d\n", a, b);
mySwap(&a, &b);这边对应使用指针的替换函数
printf ("a = %d, b = %d\n", a, b);
return 0;
}
结构体引用 ：
#include
using namespace std;
struct Student
{
int id;
const char *name;
};
//void print(Student *ps)
//{
// printf ("id = %d, name = %s\n", ps->id, ps->name);//用指针调用id name
//}
void print(Student &s)
{
printf ("id = %d, name = %s\n", s.id, s.name);//用引用调用id name
}
void func1(Student **ps)//这边直接写* ps会出现段错误
{
*ps = (Student *)malloc(sizeof(Student)/sizeof(char));
(*ps)->id = 2;
(*ps)->name = "小红";
}
void func1(Student* &ps)//这边ps给psl对应空间取了个别名
{
ps = (Student *)malloc(sizeof(Student)/sizeof(char));
ps->id = 2;
ps->name = "小红";
}
int main()
{
Student s = {1, "夏明"};
//printf ("id = %d, name = %s\n", s.id, s.name);
print(s);
print(&s);
Student *ps1 = NULL;
// func1(&ps1);
func1(ps1);//引用
printf ("id = %d, name = %s\n", ps1->id, ps1->name);
return 0;
} 引用的返回值：#include
using namespace std;
struct Test
{
double &c1;
double &c2;
};
// 引用的本质 是一个 常指针
// int &ra ===> int * const pa;
int main1()
{
int a = 10;
int &b = a; // int *const pb = &a;
b = 20; // *pb = 20 &b === &*pb === &a;
return 0;
}
// 引用作为函数的返回值: 不能返回局部变量的引用
// 可以返回 静态变量 全局变量的引用
int &func()
{
static int a = 0;
printf ("a = %d\n", a);
return a;
}
int main2()
{
// 1、不接收返回值
func();
cout <<"---------------------------" < 
int add(const int &ra, const int &rb)
{
return ra + rb;
}
int a = 10;
int main()
{
int b = 20;
int &c=b;
b=12;
cout<函数做左值，返回值必定是引用
#include
using namespace std;
// 宏 宏常量 宏函数
// 建议用 const 替换宏常量
// 建议用 内联函数 替换宏函数
// 内联函数
// 定义： 在函数定义前加 inline 关键字， 在声明前加无效
inline int add(int a, int b)
{
return a+b;
}
#define ADD(a,b) a+b//在c语言中要加括号
// 注意：
// 1、内联是一种请求，不一定通过
// 2、函数不要太长，5行以内
// 3、内联函数不要有循环语句和复杂的条件判断语句
// 4、内联成功，编译完以后，函数在可执行程序中是不存在的，不能对内联函数进行取地址操作，不能作为回调函数使用
int main()
{
cout << ADD(10, 20)*ADD(3,4) << endl;
cout << add(10, 20)*add(3,4) << endl;
return 0;
}