C++输入输出:
#include <stdlib.h> #include <iostream> #include <string> using namespace std;
/** * C++输入输出demo */ int main() { int x, y; cout << "C++"; cout << "666666" <<
endl; cout << "006030 -> " << 3 + 0 + 6 << endl; cin >> x >> y; cin >> x >> y;
cin >> y; cout << "x + y -> " << x + y << endl; return 0; }
C++新特性:
#include <iostream> using namespace std; int main() { // 1、新的数据类型 bool flag =
true; if(flag){ cout << flag << endl; cout << boolalpha << flag << endl; } //
2、直接初始化 int i(32); cout << i << endl; const j(10); cout << j << endl; //
3、随用随定义跟Java类似 return 0; }
C++数据类型的引用:
#include <iostream> using namespace std; typedef struct { int x; int y; }
Coor; // 用指针交换两个数 void fun(int *a, int *b) { int c = 0; c = *a; *a = *b; *b =
c; } // 用C++引用交换两个数 void fun(int &a, int &b) { int c = 0; c = a; a = b; b = c;
} // 普通常量不能实现交换 void fun1(int a, int b) { int c = 0; c = a; a = b; b = c; } /**
* 不管是变量的引用还是结构体或者其它都必须要先初始化 */ int main() { // 1、变量的引用 int a = 3;
//b就相当于是a的别名,即是另外一个引用方式,操作b即是操作了a,操作a即是操作了b int &b = a; //必须要初始化引用 cout << "b =
" << b << endl; b = 10; cout << "a = " << a << endl; //2、结构体的引用 Coor c1; Coor
&c = c1; //必须要初始化引用 c.x = 10; c.y = 20; cout << "c1.x = " << c1.x << endl; cout
<< "c1.y = " << c1.y << endl; // 3、指针类型的引用 // 类型 *&指针引用名 = 指针变量 int x = 10; int
*p = &x; //必须要初始化引用 int *&q = p; // 这边赋值的仍然是一个地址,即是q是一个地址 *q = 20; cout << "q =
" << q << endl; cout << "x = " << x << endl; *p = 30; cout << "p = " << p <<
endl; // p代表的是地址 cout << "*p = " << *p << endl; // *p代表的是指向这个内存地址的值 int v = 15,
f = 10; fun(&v, &f); cout << "v = " << v << endl; cout << "f = " << f << endl;
fun(v, f); cout << "v = " << v << endl; cout << "f = " << f << endl; fun1(v,
f); cout << "v = " << v << endl; cout << "f = " << f << endl; return 0; }
C++命名空间:
#include <stdlib.h> #include <iostream> #include <string> using namespace std;
namespace myNameSpace { int A; class Liu{ public: void setA(){ A = 20; } };
void print(){ cout << "A :" << A << endl; } int getMax(int num) { return num; }
} using namespace myNameSpace; int main() { myNameSpace::A = 10;
myNameSpace::print(); myNameSpace::Liu liu; liu.setA(); print(); std::cout <<
"命名空间的使用:" << myNameSpace::getMax(9) << std::endl; return 0; }
C++内存管理:
#include <iostream> using namespace std; /** * 什么是内存管理? * 内存本质是什么? 资源 *
谁掌管内存资源? 操作系统 * 我们能做什么? 申请/归还 * 申请/归还内存资源就是内存管理 */ /** 一、 对象是如何存储在内存中的? * 内存分区
* 1、栈区 int i = 1;定义一个变量 * 2、堆区 int *p = new int[10]; * 3、全局区 存储的全局变量和静态变量 *
4、常量区 string str = "c++" * 5、代码区 存储逻辑代码的二进制 */ int main() { /** * C语言内存申请和释放 *
void *malloc(size_t size) * void free(void *memblock) */ /** *
C++中内存申请和释放使用关键字new和delete,需要配套使用 */ //申请 int *p = new int(10); if (NULL == p)
{ system("pause"); return 0; } //释放 delete p; p = NULL; //如何申请和释放内存块? int *arr
= new int[1000]; //假设内存申请失败 if (NULL == arr) { system("pause"); return 0; }
delete[] arr;//如果不加[],则只会释放arr[0]的内存 arr = NULL; cout << "C++内存管理" << endl;
return 0; }
C++堆栈内存使用方式:
#include <stdlib.h> #include <iostream> using namespace std; class Tv {
public: int x = 10; int y = 20; void px() { cout << x << endl; } void py() {
cout << y << endl; } }; int main() { Tv tv; cout << tv.x << endl;
//在内存开辟一块栈空间,不需要主动释放 tv.px(); tv.py(); // Tv *tvNew; Tv *tvNew = new Tv(); //
向内存申请一块堆空间 if (NULL == tvNew) { system("pause"); return 0; } // 类似于C语言的写法 cout
<< (*tvNew).x << endl; (*tvNew).px(); (*tvNew).py(); // 类似于NDK编程的写法 cout <<
tvNew->x << endl; tvNew->px(); tvNew->py(); delete tvNew; // 在内存中申请的堆空间,需要主动释放
tvNew = NULL; return 0; }
C++类对象的定义与使用:
#include <iostream> using namespace std; class Tv { public: int x = 10; int y
= 20; void px() { cout << x << endl; } void py() { cout << y << endl; } }; int
main() { Tv tv;//在内存开辟一块栈空间,不需要主动释放 Tv tvs[10]; //申请一块连续的内存空间 cout << tv.x <<
endl; tv.px(); tv.py(); // Tv *tvNew; Tv *tvNew = new Tv(); // 向内存申请一块堆空间 if
(NULL == tvNew) { system("pause"); return 0; } // 类似于C语言的写法 cout << (*tvNew).x
<< endl; (*tvNew).px(); (*tvNew).py(); // 类似于NDK编程的写法 cout << tvNew->x << endl;
tvNew->px(); tvNew->py(); delete tvNew; // 在内存中申请的堆空间,需要主动释放 tvNew = NULL; Tv
*tvss = new Tv[10]; if(NULL == tvss){ return 0; } delete []tvss;//删除栈区所有的Tv对象
tvss = NULL; return 0; }
C++函数新特性:
#include <iostream> using namespace std; //函数默认值规则:有默认参数值的参数 ,必须要在参数列表的最右端
//给函数参数默认值时推荐声明函数时给出,不推荐定义函数时再给,因为函数声明时给出则可通过所有编译器,而函数定义时给出可能过不了某些编译器 /** *
函数声明 */ void fun(int i, int k = 5, int j = 10); //void fun(int i,int k = 5, int
j);// 编译出错 /** * 函数定义 */ void fun(int i, int k, int j) { cout << i << k << j <<
endl; } /** * 声明内联函数 inline关键字:内联函数编译器处理时相当于只调用方法体里面的逻辑,好处省时,适用于循环调用该函数时用 * *
为什么不把所有函数都写成内联函数? * 1、内联编译时建议性的,由编译器决定 * 2、逻辑简单,调用频繁的函数建议使用内联 *
3、递归函数无法使用内联方式,编译器会把递归函数当成普通函数处理 */ inline int getMax(int i, int j, int k); int
getMax(int i, int j, int k) { int max = 0; if(i>j){ max = i; }else{ if(j>k){
max = j; }else{ max = k; } } return max; } /** * 1、函数参数默认值 * 2、函数重载 * 3、内联函数 */
int main() { // 无实参值则用默认参数值,否则实参值覆盖函数默认值 fun(20); fun(20, 30); fun(20, 30, 40);
// 内联函数使用: int i = 1, j = 2, k = 3, max; max = getMax(i, j, k); cout << "max =
" << max << endl; return 0; } /*************函数重载***********************/ //
在相同作用域内,函数名称相同,参数个数,参数类型或者返回值不同的称之为函数重载 int getMax(int i, int j) { // to do
return 0; } float getMax(float i, float j) { // to do return 0; } double
getMax(double i, double j) { // to do return 0; }
C++string类型的使用:
#include <iostream> #include <string>//引入头文件 using namespace std; int main() {
string name = "liugx"; string age("27");//直接初始化 string s1(name); string
s2(5,'c'); cout << name << age << endl; cout << s1 << s2 << endl;
if(!name.empty()) cout << s1 << s2 << endl; s1 = name + age; name = age; /** *
0、与java不同,string类型是小写s开头 * 1、与java不同,要取字符串中的某个字符直接数组下标方式获取 *
2、与java不同,判断两个字符串相等不用equeals()方法 *
3、与java不同,两个固定字符串不能相加,中间需要加上一个变量字符串才能相加-------------特别注意 * string s3 =
"hello"+"hailo" 错误方式 * string s3 = "hello"+ name +"hailo" 正确方式 */ cout <<
name[0] << endl; if(s1 == s2){ }else if(s1 != s2){ } return 0; }
C++关键字const的使用:
#include <iostream> using namespace std; #define X 3 //宏定义常量跟const常量的区别
宏定义编译器不会检查语法错误,而const则会检查语法问题 /** * const与java中的final类似,被修饰的基本变量是不能改变其内容的 */
int main() { // 1、const修饰基本变量 const int x = 3; // x的值不能再被改变 // 2、const修饰指针变量 //
这两种完全等价 const int *p = NULL; int const *p = NULL; // 此时修饰的是*p *p不能赋值,但是p可以赋值
int * const p = NULL; // 此时修饰的是p p不能赋值,但是*p可以赋值 // 这两种完全等价 const int * const p
= NULL; int const * const p = NULL; // 此时修饰的是*p和p,*p和p都不能赋值 // 3、const修饰别名引用
int x = 3; const int &y = x; // 此时修饰的是引用y,y不能再赋值,x可以赋值 const int x = 3; int *y
= &x; // 用可变的*y去操作不可变的x,权限大-权限小 编译器出错 int x = 3; const int *y = &x; //
*y不可变,x可变,权限小-权限大 正确写法 // cout << "C++" << endl; return 0; } void fun(const int
&a,const int &b){ // 被const修饰过的形参a和b不能改变其值 } //常对象 //
//如果在声明对象的时候用const修饰,则称被声明的对象为常对象。常对象的数据成员值在对象的整个生命周期内不能被改变。 // //定义:类名 const
对象名[(参数表)]或者const 类名 对象名[(参数表)] //
//在定义对象时必须进行初始化,而且不能被更新,C++不允许直接或间接的更改常对象的数据成员。 // //常对象成员 // //(1) 常数据成员 //
//类的数据成员可以是常量或常引用,使用const说明的数据成员称为常数据成员。如果在一个类中声明了常数据成员,那么构造函数就只能通过初始化列表对该数据成员进行初始化,而任何其他的函数都不能对该成员函数赋值。
// //(2) 常成员函数 // //在类中使用关键字const的函数称为常成员函数,常成员函数的格式如下: // //返回类型
函数名(参数表)const; // //const是函数类型的组成部分,所以在函数的实现部分也要带关键字const。 //如: void showDate()
const; // 声明 void showDate() const // 实现 { printf(“year”); } //说明: //
//  a. 如果将一个对象声明为常对象,则通过该对象只能调用它的常成员函数,而不能调用普通的成员函数。常成员函数是常对象的唯一的对外接口。 //
//  b. 常成员函数不能更新对象的数据成员,也不能调用该类中的普通成员函数,这就保证了在常成员函数中绝对不会更新数据成员的值。
C++关键字const常指针和常引用:
#include <iostream> using namespace std; class Coordinate { public:
Coordinate(int x, int y); void print(); void println() const; void setX(int x);
void changeX() const; //常成员函数 void changeX(); // 以上两个changeX()函数互为重载 // const
Coordinate coor; // coor.changeX();//此时调用的为常成员函数 // Coordinate coor; //
coor.changeX();//此时调用的为普通成员函数 //说明: //
//  a. 如果将一个对象声明为常对象,则通过该对象只能调用它的常成员函数,而不能调用普通的成员函数。常成员函数是常对象的唯一的对外接口。 //
//  b. 常成员函数不能更新对象的数据成员,也不能调用该类中的普通成员函数,这就保证了在常成员函数中绝对不会更新数据成员的值。 private: int
mX; int mY; }; #include "Coordinate.h" Coordinate::Coordinate(int x,int
y):mX(x),mY(y){ cout << "Coordinate()" << endl; } void Coordinate::print(){
cout << "mx = " << mX << endl; cout << "my = " << mY << endl; } void
Coordinate::setX(int x){ mX = x; } void Coordinate::changeX() const{//
常成员函数不能修改数据成员的值 // mX = 20; } void Coordinate::changeX() { mX = 20; } void
Coordinate::println() const{ cout << "调用常成员函数" << endl; cout << "mx = " << mX
<< endl; cout << "my = " << mY << endl; } #include "Coordinate.h" #include
<iostream> using namespace std; int main() { Coordinate coor(1, 2);
coor.println(); // Coordinate &coor2(coor); // coor2.println(); // //
Coordinate *pcoor = &coor; // pcoor->println(); const Coordinate &coor2(coor);
coor2.println(); // coor2.setX(0);//出错 // 常对象成员,常指针,常引用只能调用常成员函数,不能调用普通函数 const
Coordinate *pcoor = &coor; pcoor->println(); pcoor->setX(0);//
出错:注意const修饰的位置,此时pcoor为常对象,只能调用常成员函数 Coordinate * const pcoor1 = &coor;//
注意const修饰的位置,此时pcoor1为常指针,pcoor1指针只能指向coor pcoor1->setX(0);// 不出错
pcoor1->println(); pcoor1 = &coor2;// 编译出错 return 0; }
C++关键字const常对象成员和常成员函数:
#include <iostream> #include "Coordinate.h" using namespace std; class Line {
public: // Line(); Line(int x1, int y1, int x2, int y2); ~Line(); // void
setA(int x,int y); // void setB(int x,int y); Coordinate getCoorA(); Coordinate
getCoorB(); void changeA() const; //常成员函数 void changeB(); private: const
Coordinate m_A; //常成员对象 const Coordinate m_B; }; #include "Line.h"
//Line::Line(){ // cout << "Line()" << endl; //} Line::Line(int x1, int y1, int
x2, int y2) : m_A(x1, y1), m_B(x2, y2) { cout << "Line()" << endl; }
Line::~Line() { cout << "~Line()" << endl; } Coordinate Line::getCoorA() {
return m_A; } Coordinate Line::getCoorB() { return m_B; } void Line::changeA()
const { // 常成员函数不能修改数据成员的值 // m_A... } void Line::changeB() { } #include
<iostream> using namespace std; class Coordinate { public: Coordinate(int x,
int y); void print(); void setX(int x); void changeX() const; //常成员函数 void
changeX(); // 以上两个changeX()函数互为重载 // const Coordinate coor; //
coor.changeX();//此时调用的为常成员函数 // Coordinate coor; //
coor.changeX();//此时调用的为普通成员函数 //说明: //
//  a. 如果将一个对象声明为常对象,则通过该对象只能调用它的常成员函数,而不能调用普通的成员函数。常成员函数是常对象的唯一的对外接口。 //
//  b. 常成员函数不能更新对象的数据成员,也不能调用该类中的普通成员函数,这就保证了在常成员函数中绝对不会更新数据成员的值。 void
println() const; private: int mX; int mY; }; #include "Coordinate.h"
Coordinate::Coordinate(int x,int y):mX(x),mY(y){ cout << "Coordinate()" <<
endl; } void Coordinate::print(){ cout << "mx = " << mX << endl; cout << "my =
" << mY << endl; } void Coordinate::setX(int x){ mX = x; } void
Coordinate::changeX() const{// 常成员函数不能修改数据成员的值 // mX = 20; } void
Coordinate::changeX() { mX = 20; } void Coordinate::println() const{ cout <<
"调用常成员函数" << endl; cout << "mx = " << mX << endl; cout << "my = " << mY <<
endl; } #include <iostream> using namespace std; #include "Line.h" /** *
1、常成员对象的值不能被修改 * * 2、常成员函数不能修改数据成员的值 */ int main() { Line line(1, 3, 5, 8);
line.getCoorA().println(); line.getCoorB().print(); return 0; }