JavaInterview
JavaInterview.cn
2022-10-05
目录

C++代码示例Java

文章发布较早，内容可能过时，阅读注意甄别。

# 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;
}
微信 支付宝
C++语法
Lombok原理

← Lombok原理→

最近更新
01
合并石头的最低成本 Java
10-26
02
力扣模版 Java
10-26
03
网格照明 Java
10-26
更多文章>
Theme by Vdoing | Copyright © 2019-2024 JavaInterview.cn