C++基本語法總結
阿新 • • 發佈：2018-12-13
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;
}