【CPP】C++学习笔记

已于 2023-01-07 17:50:13 修改
阅读量363 收藏
点赞数 1
文章标签： c++ 学习 开发语言
于 2023-01-07 17:41:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/karl_clemens/article/details/128593210
版权

2023-1-7 markclemens

文章目录

hello.cpp

#include<iostream> 
using namespace std; 
 
int main() { 
    char c;
    bool ischar; 
    int isLowercaseVowel,isUppercaseVowel;
    cout<<"输入一个字母："; 
    cin>>c; 
    ischar=((c>='a'&&c<='z')||(c>='A'&&c<='Z'));
    if(ischar) {
        // 小写字母元音
        isLowercaseVowel=(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'); 
        // 大写字母元音
        isUppercaseVowel=(c=='A'||c=='E'||c=='I'||c=='O'||c=='U');
        // if 语句判断
        if(isLowercaseVowel||isUppercaseVowel)
            cout<<c<<" 是元音"; 
        else 
            cout<<c<<" 是辅音"; 
    } else {
        cout<<"输入的不是字母。"; 
    }
        
    return 0; 
}

class_demo.cpp

#include <iostream>
#include <cstring>

using namespace std;

class Box
{
public:
    static int box_count;
    int length;
    int breadth;
    int height;

    // 构造函数 constructor
    Box()
    {
        cout << "constructor(default)..." << endl;
        box_count++;
    }

    // 析构函数 destructor
    ~Box()
    {
        cout << "destructor(default)..." << getName() << endl;
        // if (name != NULL) free(name); // also ok
        delete name;
    }

    Box(int, int, int, char[]); //constructor
    Box(const Box &);           // copy-constructor

    // 成员函数声明
    static void printCount(void) { cout << "static box count:" << box_count << endl; }
    int get(void) { return length * breadth * height; }
    char *getName(void) { return this->name; }
    void set(int, int, int, char[]);
    void display(void);

private:
    char *name; //默认情况下，不写修饰符，类的所有成员都是私有的
};

// 静态成员初始化
int Box::box_count = 0;

int main()
{
    char p1[] = "box1";
    Box box1;
    box1.set(3, 4, 5, p1); // constructor(default)
    box1.display();

    char p2[] = "box2";
    Box box2(1, 4, 5, p2); // constructor(with params)
    box2.display();

    Box box3 = Box(box2), *pBox; // copy constructor()
    pBox = &box3;
    pBox->display();
    Box::printCount();

    return 0;
}

// 有参构造函数 + 委托构造函数
Box::Box(int l, int w, int h, char p[]) : Box()
{
    cout << "constructor(with params)..." << endl;
    this->length = l;
    this->breadth = w;
    this->height = h;
    this->name = p;
}
// 拷贝构造函数
Box::Box(const Box &box) : length(box.length), breadth(box.breadth), height(box.height), name(box.name)
{
    cout << "copy constructor()..." << endl;
    box_count++;
    // name = new char[strlen(box.name) + 1];
    strcpy(name, box.name);
    strcat(name, "*");
}
// 成员函数定义 ===================================
void Box::set(int length, int breadth, int height, char p[])
{
    this->length = length;
    this->breadth = breadth;
    this->height = height;
    this->name = p;
}
void Box::display()
{
    clog << "volume: " << get() << ", box_count: " << box_count << endl
         << "length: " << length
         << ",breadth: " << breadth
         << ",height: " << height
         << ",name: " << getName() << endl
         << endl;
}

cout_setw.cpp

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    cout << setiosflags(ios::right | ios::showpoint); // 设右对齐，以一般实数方式显示
    cout.precision(5);                                // 设置除小数点外有五位有效数字
    cout << 123.456789 << endl;
    cout.width(10); // 设置显示域宽10
    cout.fill('*'); // 在显示区域空白处用*填充

    cout << setw(8) << 123.456789 << endl; // setw 只对紧接着的一次输出生效！

    char name[50];
    cout << "Input a name:";
    cin >> name;
    clog << "INFO: get a name:" << name << endl;
    cerr << "ERROR: this program crash!" << endl;

    return 0;
}

friend_demo.cpp

#include <iostream>

using namespace std;

class Box
{
    double width;

public:
    // 将外部函数注册为友元函数
    friend void printWidth(Box box);

    // 将外部类注册为友元类
    friend class Friend;

    void setWidth(double wid)
    {
        width = wid;
    }
};

class Friend
{
public:
    char name[12] = "FriendClass";
    void Print(int width, Box &box)
    {
        box.width = width;
        cout << "Outer class (friend class) can access Box class: width:" << box.width << endl;
    }
};

void printWidth(Box box)
{
    cout << "Outer function (friend func) can access Box class: width:" << box.width << endl;
}

int main()
{
    Box box;
    box.setWidth(123);
    printWidth(box); // friend func

    Friend f;
    f.Print(456, box); // friend class

    getchar(); //stop
    return 0;
}

inline_demo.cpp

#include <iostream>
 
using namespace std;

inline int Max(int x, int y)
{
   return (x > y)? x : y;
}

// 程序的主函数
int main( )
{
    // 内联：编译器在函数调用处直接将函数替换为函数体，类定义里的函数默认是内联函数。 建议内联函数不要超过10行
   cout << "Max (20,10): " << Max(20,10) << endl;
   cout << "Max (0,200): " << Max(0,200) << endl;
   cout << "Max (100,1010): " << Max(100,1010) << endl;
   return 0;
}

lambda_demo.cpp

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional> // define lambda

using namespace std;

int main()
{
    // Lambda 表达式把函数看作对象
    // 在Lambda表达式内可以访问当前作用域的变量，这是Lambda表达式的闭包（Closure）行为。

    vector<int> v = {1, 2, 3, 4, 5};
    int even_count = 0;

    // 对象化，这样是为了其他地方也能用
    function<void(int &)> lamb = [&even_count](int &x) mutable -> void
    {
        if (!(x & 1))
            even_count++;
        x += 2;
    };
    for_each(v.begin(), v.end(), lamb);

    cout << "Lambda >> even_count: " << even_count << endl;
    // lambda: [capture](parameters) mutable ->return-type{statement}

    for (int i = 0; i < v.size(); i++)
        cout << v[i] << " ";
    return 0;
}

namespace.cpp

#include <iostream>
using namespace std;
 
// 第一个命名空间
namespace first_space{
   void func(){
      cout << "Inside first_space" << endl;
   }
}
// 第二个命名空间
namespace second_space{
   void func(){
      cout << "Inside second_space" << endl;
   }
}
using namespace first_space;
int main ()
{
 
   // 调用第一个命名空间中的函数
   func();
   
   return 0;
}

polymorphism.cpp

#include <iostream>
using namespace std;

class Shape
{
protected:
   int width, height;

public:
   Shape(int a = 0, int b = 0)
   {
      width = a;
      height = b;
   }
   // 纯虚函数 --没有函数体的
   // virtual int area1() = 0;

   // 虚函数
   virtual int area()
   {
      cout << "Parent class area :" << endl;
      return 0;
   }
};

class Rectangle : public Shape
{
public:
   Rectangle(int a = 0, int b = 0) : Shape(a, b) {}
   int area()
   {
      cout << "Rectangle class area :" << endl;
      return (width * height);
   }
};

class Triangle : public Shape
{
public:
   Triangle(int a = 0, int b = 0) : Shape(a, b) {}
   int area()
   {
      cout << "Triangle class area :" << endl;
      return (width * height / 2);
   }
};

// 程序的主函数
int main()
{
   Shape *shape;
   Rectangle rec(10, 7);
   Triangle tri(10, 5);

   // 存储矩形的地址
   shape = &rec;
   // 调用矩形的求面积函数 area
   shape->area();

   // 存储三角形的地址
   shape = &tri;
   // 调用三角形的求面积函数 area
   shape->area();

   return 0;
}

signal_demo.cpp

#include <iostream>
#include <csignal>
#include <unistd.h>
#include <cassert>

using namespace std;

void signalHandler(int signum)
{
    cout << "Interrupt signal (" << signum << ") received.\n";

    // 清理并关闭
    // 终止程序

    exit(signum);
}

int main()
{
    int i = 0;
    
    // 断言
    assert(i == 0);
    // assert(i != 0);

    // 注册信号 SIGINT 和信号处理程序
    signal(SIGINT, signalHandler);

    while (++i)
    {
        cout << "Going to sleep...." << endl;
        if (i == 3)
        {
            raise(SIGINT);
        }
        sleep(1);
    }

    return 0;
}

template_demp.cpp

#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>
#include <functional>

using namespace std;

template <typename T>
inline T const &Max(T const &ele1, T const &ele2)
{
    return (ele1 > ele2) ? ele1 : ele2;
}

template <typename T>
function<void(T &, T &)> lamb = [](T &ele1, T &ele2) -> void
{
    const type_info &typeT = typeid(ele1);
    cout << "template func -- Max<" << typeT.name() << ">: " << Max(ele1, ele2) << endl;
};

template <class T>
class Stack
{
public:
    void push(T const &); // 入栈
    void pop();           // 出栈
    T top() const;        // 返回栈顶元素
    bool empty() const
    { // 如果为空则返回真。
        return elems.empty();
    }

private:
    vector<T> elems; // 元素
};

int main()
{
    string s1 = "abc", s2 = "ac";
    lamb<string>(s1, s2);

    int i1 = 15, i2 = 48;
    lamb<int>(i1, i2);

    double d1 = 123, d2 = 456;
    lamb<double>(d1, d2);

    Stack<string> stringStack; // string 类型的栈
    stringStack.push("hello");
    stringStack.push("workd");
    cout << "template class -- " << stringStack.top() << endl;
    stringStack.pop();
    cout << "template class -- " << stringStack.top() << endl;

    return 0;
}

template <class T>
void Stack<T>::push(T const &elem)
{
    // 追加传入元素的副本
    elems.push_back(elem);
}

template <class T>
void Stack<T>::pop()
{
    if (elems.empty())
    {
        throw out_of_range("Stack<>::pop(): empty stack");
    }
    // 删除最后一个元素
    elems.pop_back();
}

template <class T>
T Stack<T>::top() const
{
    if (elems.empty())
    {
        throw out_of_range("Stack<>::top(): empty stack");
    }
    // 返回最后一个元素的副本
    return elems.back();
}

vector_iterator.cpp

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void traverse(const void *p)
{
    vector<int> v = *(vector<int> *)p;

    // 下标访问
    for (int i = 0; i < v.size(); i++)
    {
        cout << "v[" << i << "]" << v[i] << ", ";
    }
    cout << endl;

    // 迭代器访问
    vector<int>::iterator it = v.begin();
    while (it != v.end())
    {
        cout << "v[i]" << *it++ << ", ";
    }
    cout << endl;
}

int main()
{
    // Lambda 表达式把函数看作对象
    // 在Lambda表达式内可以访问当前作用域的变量，这是Lambda表达式的闭包（Closure）行为。

    vector<int> v = {1, 2, 3, 4, 5};
    int even_count = 0;

    // 偶数计数
    for_each(v.begin(), v.end(), [&even_count](int &x)
             {
                 if (!(x & 1))
                     even_count++;
                 else
                     x = 666;
             });
    cout << "Lambda >> even_count:" << even_count << ". vector size:" << v.size() << endl;
    //[capture](parameters) mutable ->return-type{statement}

    v.pop_back();
    v.push_back(777);

    traverse((void *)&v);
    return 0;
}

pointer.cpp

#include <iostream>
 
using namespace std;

int main ()
{
   int  var1;
   char var2[10];
 
   cout << "var1 变量的地址： ";
   cout << &var1 << endl;
 
   cout << "var2 变量的地址： ";
   cout << &var2 << endl;
 
   return 0;
}

end

MarkClemens
关注
C++判断字符是否是元音字母
weixin_30879169的博客
09-05 3029
写这个随笔的起因很奇怪。 我本来想找找C++有没有内置的函数（类似isalpha(), isdigit(), isalnum()之流）能直接完成这个功能，但是函数没发现，却发现很多博客都是逐个字符判断的写法： isLowercaseVowel = (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u'); isUppercase...
c语言辅音字符怎么表示,C 语言实例 - 判断元音/辅音
weixin_30239977的博客
05-19 526
C 语言实例 - 判断元音/辅音C 语言实例 C 语言实例判断输入的字母是元音，还是辅音。英语有26个字母，元音只包括 a、e、i、o、u 这五个字母，其余的都为辅音。y是半元音、半辅音字母，但在英语中都把他当作辅音。实例#include int main(){char c;int isLowercaseVowel, isUppercaseVowel;printf("输入一个字母: ");scan...
c++ 判断是元音还是辅音
weixin_30861797的博客
06-05 2361
#include <iostream> using namespace std; int main() { char c; int isLowercaseVowel, isUppercaseVowel; cout << "输入一个字母: "; cin >> c; // 小写字母元...
C 语言实例 - 判断元音/辅音
weixin_30642561的博客
03-09 3339
C 语言实例 - 判断元音/辅音 C 语言实例 C 语言实例 判断输入的字母是元音，还是辅音。 英语有26个字母，元音只包括 a、e、i、o、u 这五个字母，其余的都为辅音。y是半元音、半辅音字母，但在英语中都把他当作辅音。 实例 #include <stdio.h> int main() { char c; int isLowercaseV...
CPP/C++学习笔记06
qq_48637306的博客
09-07 125
主要内容：模板
c++学习笔记精华版
08-27
### C++ 学习笔记精华版 #### 一、C++ 语言概述 **1、历史背景** - **C++ 的江湖地位** - Java、C、C++、Python、C# 是当前主流的编程语言之一，而 C++ 在这些语言中以其高效性和灵活性著称。 - **C++ 之父 ...
C++学习笔记 C++学习笔记
08-06
在C++中，程序通常包含源代码文件，其扩展名可以是".cc", ".cp", 或 ".cpp"。 1. **进制转换**： - 十进制转二进制：通过除以2取余法。 - 二进制转十进制：将二进制每位与对应权重相乘后求和。 - 十进制转十六...
Cpp.rar - C++学习笔记
03-23
标题"Cpp.rar - C++学习笔记"暗示了这份压缩包可能包含一系列关于C++的学习资料，比如笔记、代码示例或者教程。这些笔记可能会涵盖C++的基础语法、类与对象、模板、异常处理、STL（标准模板库）、内存管理等方面。...
C++学习笔记
07-22
- C++则通常使用`.cpp`作为源文件的扩展名。 2. **兼容性**： - C++完全兼容C语言，即所有合法的C代码都可以被C++编译器正确编译。 - 反之，由于C++引入了许多新的特性，部分C++代码可能无法在纯C编译器中正确...
C++整理笔记word版——01 C++学习笔记
12-05
C++是一种强大的面向对象编程语言，它源自C语言并扩展了其...学习这些概念是成为C++程序员的第一步。在实际编程中，还需要理解类、对象、继承、多态等面向对象编程的概念，以及函数、模板、文件操作等更高级的主题。
C语言实例分析
cula的博客
03-18 1690
最新在菜鸟教程学习C语言，在里面的例程代码中做一些注释，供学习使用。
C++ 判断元音/辅音
weixin_45743799的博客
03-24 1990
C++判断元音还是辅音，并输出在控制台上。 我们知道英语有 26 个字母，元音只包括 a、e、i、o、u 这五个字母，其余的都为辅音。y是半元音、半辅音字母，但在英语中都把他当作辅音。 用户根据提示输入任意字母，程序判断输入的字母是元音还是辅音并在控制台输出显示。 完整代码 #include <iostream> using namespace std; int main() { ...
C++类成员函数、访问修饰符和继承方式
江江江洗河
10-12 617
C++在 C 语言的基础上增加了面向对象编程，C++支持面向对象程序设计。类是 C++ 的核心特性，通常被称为用户定义的类型。 类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。 C++ 类定义 定义一个类，本质上是定义一个数据类型的蓝图。这实际上并没有定义任何数据，但它定义了类的名称意味着什么，也就是说，它定义了类的对象包括...
\t\t谭浩强 C++ 学习笔记
cuihao0532的博客
12-05 583
1 以const加以限定的引用的值不能改变，但是该引用对应的变量的值如果不是const则可以改变 2 可以用常量或表达式对引用进行初始化，但是必须加const加以限定 3 函数模板  template  //这里没有“逗号” inline T Max(T a, T b) {   //代码 }  所以应写成这样#include "stdio.h"#include using namespace st
C语言 12 函数
天河有尽后为涯，星海无边前作岸。
09-13 1117
程序的入口点就是main函数，只需要将程序代码编写到主函数中就可以运行了，不过这个函数只是由我们来定义，而不是我们来调用。当然，除了主函数之外，一直在使用的printf那么，函数的具体定义是什么呢？函数是完成特定任务的独立程序代码单元。每次要做这个任务时，都要完完整整地将任务的每一行代码都写下来，如果程序中多处都需要执行这个任务，每个地方都完整地写一遍，实在是太臃肿了，有没有一种更好的办法能优化代码呢？
CF C. Nikita and LCM
qq_74190237的博客
09-13 283
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++与QML的数据交互
qq_50679120的博客
09-11 541
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
C++_map_set详解
最新发布
2302_77644537的博客
09-16 850
set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格的排序准则（默认是小于）进行排序。set在底层是用二叉搜索树(红黑树)实现的。map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
C++学习笔记：重载函数调用运算符详解
"这篇文档是关于C++学习的笔记，主要讲解了重载函数调用运算符的概念和应用。文章提到了重载函数调用运算符`()`在C++中的特性，包括它必须返回对象的引用以便用作左值，需要至少一个形式参数，并且只能用成员函数来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值