Information and Computer Science 45C — Week 2 整合 Reading 笔记

// 例：测试一个判断是否为偶数的函数
bool isEven(int x) {
    return (x % 2) == 0;
}

// 测试用例应包括：
// 正常情况：isEven(4) -> true, isEven(7) -> false
// 边界情况：isEven(0) -> true, isEven(1) -> false
// 负数情况：isEven(-2) -> true, isEven(-3) -> false

int main() {
    std::cout << isLowerVowel('a') << '\n';  // 应输出 1
    std::cout << isLowerVowel('q') << '\n';  // 应输出 0
    return 0;
}

void testVowel() {
    std::cout << isLowerVowel('a') << '\n';  // 应输出 1
    std::cout << isLowerVowel('q') << '\n';  // 应输出 0
}

int testVowel() {
    if (!isLowerVowel('a')) return 1;  // 测试 1 失败
    if (isLowerVowel('q')) return 2;   // 测试 2 失败
    return 0;                           // 所有测试通过
}

项目结构：
  main.cpp     —— 主程序
  add.cpp      —— add 函数的定义
  add.h        —— add 函数的声明（头文件）

#ifndef ADD_H
#define ADD_H

int add(int x, int y);   // 函数声明（前向声明）

#endif

#include "add.h"

int add(int x, int y) {   // 函数定义
    return x + y;
}

#include <iostream>
#include "add.h"

int main() {
    std::cout << add(3, 4) << '\n';   // 输出: 7
    return 0;
}

g++ -o myprogram main.cpp add.cpp

#include <iostream>     // 用尖括号：搜索系统/标准库路径
#include "myheader.h"   // 用引号：先搜索当前目录，再搜索系统路径

#ifndef MY_HEADER_H    // 如果还没定义过这个宏
#define MY_HEADER_H    // 定义这个宏

// 头文件内容...
int add(int x, int y);

#endif                 // 结束

#pragma once

int add(int x, int y);

// add.h — 错误示范！把定义放在了头文件里
int add(int x, int y) {
    return x + y;
}

const int x{5};         // 运行时常量：初始化后不能改
constexpr int y{5};     // 编译时常量：编译时就确定值

const int z{getInput()};     // OK：const 可以用运行时的值初始化
// constexpr int w{getInput()};  // 错误！constexpr 必须在编译时就确定

// 坏：magic number
double area = 3.14159 * r * r;

// 好：命名常量
constexpr double pi{3.14159};
double area = pi * r * r;

const int x{10};
x = 20;   // 编译错误！不能修改 const 变量

int x{5};

int a = ++x;   // 前缀自增：先加再用。x 变成 6，a = 6
int b = x++;   // 后缀自增：先用再加。b = 6（用的是加之前的值），x 变成 7

int x{5};
std::cout << x << '\n';     // 输出: 5

std::cout << ++x << '\n';   // 输出: 6（先变成6再输出）
std::cout << x << '\n';     // 输出: 6

std::cout << x++ << '\n';   // 输出: 6（先输出6再变成7）
std::cout << x << '\n';     // 输出: 7

for (int i{0}; i < 10; ++i) {   // 推荐 ++i
    std::cout << i << '\n';
}

x = 5;    // 副作用：改变了 x 的值
++x;      // 副作用：改变了 x 的值
std::cout << x;   // 副作用：向屏幕输出了内容

int x{1};
x = x++;   // undefined behavior!

int x{5};
int value{add(x, ++x)};   // undefined behavior!
// C++ 不规定函数参数的求值顺序
// 如果先算左边：add(5, 6) = 11
// 如果先算右边：add(6, 6) = 12
// 不同编译器可能给出不同结果！

int x{1};
int y = x + ++x;   // unspecified behavior!
// Visual Studio/GCC 得到 2 + 2 = 4
// Clang 得到 1 + 2 = 3

auto x{5};        // x 是 int
auto y{3.14};     // y 是 double
auto z{"hello"};  // z 是 const char*（注意！不是 std::string）

// 没有 auto
std::vector<std::string>::iterator it = names.begin();

// 有 auto
auto it = names.begin();

auto x{5};     // x 是 int
auto y{5.0};   // y 是 double
auto z{5.0f};  // z 是 float

const int a{10};
auto b{a};     // b 是 int（不是 const int！const 被丢弃了）

// 如果想保留 const，必须显式加上：
const auto c{a};     // c 是 const int
constexpr auto d{5}; // d 是 constexpr int

for (auto s : A) cout << s;     // auto 自动推断元素类型
for (auto E : S) cout << E;     // set 遍历
for (auto E : A) cout << E.first << E.second;  // map 遍历

int x{5};

// x 是左值：它有名字，有内存地址，一直存在到作用域结束
// 5 是右值：它只是一个临时的字面量

x = 10;    // OK：左值可以出现在 = 的左边
// 10 = x; // 错误：右值不能出现在 = 的左边

int x{5};           // x 是可修改的左值（modifiable lvalue）
const double d{3.14}; // d 是不可修改的左值（non-modifiable lvalue）

x = 10;    // OK：x 是 modifiable lvalue
// d = 2.0; // 错误：d 是 non-modifiable lvalue（因为是 const）

int x{5};
int& ref{x};   // ref 是 x 的引用（别名）

std::cout << x << '\n';     // 输出: 5
std::cout << ref << '\n';   // 输出: 5

ref = 10;                    // 通过引用修改
std::cout << x << '\n';     // 输出: 10（x 也变了！）

int x{5};
int& ref{x};      // OK：引用绑定到左值 x

// int& ref2{5};   // 错误！普通引用不能绑定到右值（字面量）
// int& ref3;      // 错误！引用必须在声明时初始化

int x{5};
const int y{10};

int& ref1{x};      // OK：x 是 modifiable lvalue
// int& ref2{y};   // 错误！y 是 non-modifiable lvalue（const），普通引用不能绑
// int& ref3{5};   // 错误！5 是 rvalue

int x{5};
int& ref{x};       // OK
// double& ref2{x}; // 错误！类型不匹配

int x{5};
const int& ref{x};   // ref 是 x 的 const 引用

std::cout << ref << '\n';   // 输出: 5（可以读）
// ref = 10;                // 错误！不能通过 const 引用修改
x = 10;                     // OK：x 本身不是 const，可以直接改
std::cout << ref << '\n';   // 输出: 10（ref 反映最新的 x）

const int& ref{5};   // OK！const 引用可以绑定到右值（字面量）

// int& ref{5};   // 错误！

const int& ref{5};           // 临时对象的生命周期延长到和 ref 一样
std::cout << ref << '\n';    // 安全！输出 5
// ref 和临时对象在作用域结束时一起销毁

const double& r1{5};    // 5（int）被转换为临时 double，r1 绑定到该临时对象
char c{'a'};
const int& r2{c};       // c（char）被转换为临时 int，r2 绑定到该临时对象

std::cout << r2 << '\n'; // 输出 97（'a' 的 ASCII 值），因为 r2 是 int 引用

void addOne(int x) {
    ++x;   // 只改了副本
}

int a{5};
addOne(a);
std::cout << a << '\n';   // 输出: 5（a 没变）

void addOne(int& x) {   // x 是引用参数
    ++x;   // 修改的是原变量！
}

int a{5};
addOne(a);
std::cout << a << '\n';   // 输出: 6（a 被修改了！）

void addOne(int& x) { ++x; }

int a{5};
addOne(a);     // OK：a 是左值
// addOne(5);  // 错误！5 是右值，不能绑定到 int&

def add_one(lst):
    lst.append(1)   # 会影响原 list

# C++ 要达到同样效果，需要显式写 &
void addElement(vector<int>& v) {
    v.push_back(1);
}

void printValue(const int& x) {
    std::cout << x << '\n';
    // x = 10;   // 错误！不能通过 const 引用修改
}

int a{5};
printValue(a);    // OK
printValue(5);    // 也OK！const 引用可以接受右值

void process(const std::string& name) {   // string 可能很大，用 const& 避免拷贝
    std::cout << "Hello, " << name << '\n';
}

void foo(int a, int& b, const std::string& c) {
    // a 是值传递，b 是引用传递，c 是 const 引用传递
}

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def bark(self):
        print(f"{self.name} says Woof!")

class Complex {
    float re, im;          // 数据成员（默认 private）
public:
    // 成员函数会在后面的节里详细讲
};

struct Fraction {
    int numerator{0};
    int denominator{1};   // 不变量：denominator 不能为 0
};

Fraction f{5, 0};   // 糟糕！struct 无法阻止用户创建无效对象

Complex c1(1.5, 5.3);   // 创建一个 Complex 对象
Complex c2(2.5, 2.7);   // 再创建一个

struct Complex {
private:             // struct 默认 public，所以要手动写 private
    float re, im;
public:
    // ...
};

class Complex {
    float re, im;    // class 默认 private，不用写
public:
    // ...
};

class Complex {
    float re, im;
public:
    Complex add(Complex c) {
        return Complex(re + c.re, im + c.im);
    }
    
    void print(ostream& out) const {
        out << "(" << re << "+" << im << "i)";
    }
};

void print(ostream& out) const {
    out << "(" << re << "+" << im << "i)";
    // re 其实是 this->re
    // im 其实是 this->im
}

Complex c1(1.0, 1.0);
Complex c2(2.0, 1.0);
Complex result = c1.add(c2);   // c1 是 this，c2 是参数 c
result.print(cout);             // result 是 this

Complex add(Complex c) {
    return Complex(re + c.re, im + c.im);
    //              ^         ^
    //              this->re  c.re（即使 re 是 private，也能访问 c 的 re）
}

const Complex c1(1.0, 2.0);   // c1 是 const 对象
// c1 的数据成员不能被修改

void print(ostream& out) const {   // 注意 const 的位置
    out << "(" << re << "+" << im << "i)";
}

const Complex c(1.0, 2.0);
c.print(cout);    // OK：print 是 const 成员函数
// c.add(other);  // 如果 add 不是 const，就不能调用

class Complex {
private:              // 以下成员是私有的
    float re, im;
    
public:               // 以下成员是公开的
    Complex(float newRe = 0.0, float newIm = 0.0);
    Complex add(Complex c);
    void print(ostream& out) const;
};

class Foo {
    int x;      // 默认是 private
public:
    int y;      // 显式声明为 public
};

class Stack {
    int _top;                       // private：数据成员
    char buf[STACK_CAPACITY];       // private：数据成员
public:
    Stack() { }                     // public：构造函数
    void push(char c) { }          // public：用户接口
    bool isFull() { }              // public：用户接口
};

class Complex {
    float re, im;
public:
    Complex(float newRe = 0.0, float newIm = 0.0)
        : re(newRe), im(newIm)     // 成员初始化列表
    {
        // 构造函数体（可以做其他事）
    }
};

Complex();                              // 无参数
Complex(float newRe = 0.0, float newIm = 0.0);  // 所有参数有默认值，也可以无参调用

Complex c1;              // 调用默认构造函数
Complex c2(1.0, 2.0);   // 调用带参构造函数
Complex c3{};            // 调用默认构造函数（brace initialization）

Complex result;       // OK：调用默认构造函数
// Complex result();  // 错误！这会被解析为函数声明，不是创建对象！
Complex result{};     // OK：用花括号更安全

Complex c(1.0, 2.0);      // 前面有类型名 Complex → 变量声明
c.print(cout);             // 前面没有类型名       → 函数调用

类型名 变量名(参数);    // 变量声明 + 初始化
       函数名(参数);   // 函数调用

int x(5);              // int 是类型    → 声明变量 x
square(5);             // 没有类型      → 调用函数 square

double d(3.14);        // double 是类型 → 声明变量 d
d = sqrt(2.0);         // 没有类型      → 调用函数 sqrt

1) 分配内存（Allocation）
2) 调用构造函数（Construction）← 这里
3) 对象存活期（使用对象）
4) 调用析构函数（Destruction）
5) 释放内存（Deallocation）

class Complex:
    def __init__(self, re=0.0, im=0.0):
        self.re = re
        self.im = im

class Complex {
    float re, im;
public:
    Complex(float newRe = 0.0, float newIm = 0.0)
        : re(newRe), im(newIm) {}
};

Complex(float newRe, float newIm)
    : re(newRe), im(newIm)    // ← 这就是成员初始化列表
{
    // 函数体
}

// 方式一：成员初始化列表（推荐）
Complex(float newRe, float newIm)
    : re(newRe), im(newIm)
{ }

// 方式二：函数体内赋值（不推荐）
Complex(float newRe, float newIm)
{
    re = newRe;   // 这是赋值，不是初始化
    im = newIm;
}

class Foo {
    int m_x{};      // 默认成员初始化器：0
    int m_y{2};      // 默认成员初始化器：2
    int m_z;         // 无初始化器
public:
    Foo(int x)
        : m_x{x}    // m_x 用初始化列表的值（优先级 1）
    { }
    // m_y 没出现在列表中，用默认值 2（优先级 2）
    // m_z 没出现在列表中也没有默认值 → 未初始化！（优先级 3，危险！）
};

Foo foo{6};
// m_x = 6, m_y = 2, m_z = 垃圾值（undefined behavior if read）

class Foo {
    int a;    // 先声明 → 先初始化
    int b;    // 后声明 → 后初始化
public:
    Foo() : b(1), a(2) {}   // 尽管 b 写在前面，a 还是先初始化
};

class Foo {
    int m_x{};
    int m_y{};
public:
    Foo(int x, int y)
        : m_y{std::max(x, y)}, m_x{m_y}   // 危险！
    { }
};

Foo foo{6, 7};
// m_x 先初始化（因为先声明），但用的是还未初始化的 m_y → m_x 是垃圾值！
// m_y 后初始化为 7

class Complex {
    float re, im;
public:
    ~Complex() {   // 析构函数：波浪号 + 类名
        cout << "Complex number ";
        print(cout);
        cout << " is about to die.\n";
    }
};

int main() {
    Complex c1(1.5, 5.3);   // c1 构造
    Complex c2(2.5, 2.7);   // c2 构造
    {
        Complex result;       // result 构造（默认值 0,0）
        result = c1.add(c2);  // 赋值（涉及临时对象的构造和析构）
    }                         // result 析构（离开内层作用域）
    c1 = Complex(2.0, 3.0);  // 创建临时对象，赋值给 c1，临时对象析构
    return 0;
}                             // c2 析构，c1 析构（后构造的先析构）

Complex.hpp — 类的声明
Complex.cpp — 成员函数的定义

// Complex.hpp
#ifndef COMPLEX_HPP
#define COMPLEX_HPP

#include <iostream>

class Complex {
private:
    float re, im;
public:
    Complex(float newRe = 0.0, float newIm = 0.0);
    Complex add(Complex c);
    void print(std::ostream& out) const;
};

std::ostream& operator<<(std::ostream& out, const Complex& c);

#endif

// Complex.cpp
#include "Complex.hpp"

Complex::Complex(float newRe, float newIm)
    : re(newRe), im(newIm) {
}

Complex Complex::add(Complex c) {
    return Complex(re + c.re, im + c.im);
}

void Complex::print(std::ostream& out) const {
    out << "(" << re << "+" << im << "i)";
}

// main.cpp
#include "Complex.hpp"

int main() {
    Complex one_i(1.0, 1.0);
    Complex two_i(2.0, 1.0);
    Complex result = one_i.add(two_i);
    result.print(cout);
}

void fill(int a[], int N) {
    for (int i = 0; i < N; ++i) {
        a[i] = i;
    }
}

void print(int a[], int N) {
    for (int i = 0; i < N; ++i) {
        cout << a[i] << ' ';
    }
    cout << endl;
}

constexpr int len = 5;
int a[len] = {0};   // 所有元素初始化为 0

int a[5] = {0};
a[-1] = 0;     // undefined behavior!
a[5] = 999;    // 也是 undefined behavior!（有效索引是 0~4）

int main() {
    constexpr int len = 5;
    string A[len] = {"Mo", "Tu", "We", "Th", "Fr"};
    
    for (auto s : A) cout << s;           // OK：在 main 中，编译器知道数组大小
    for (int i = 0; i < len; ++i) cout << A[i];  // OK
}

void f(string P[], int len) {
    // for (auto s : P) cout << s;        // 不行！数组传参后退化为指针，丢失了大小信息
    for (int i = 0; i < len; ++i) cout << P[i];  // OK：用索引遍历
}

int counts[26] = {0};   // 26 个字母的计数器

// 错误做法：
// ++counts['A'];  // 'A' 的 ASCII 值是 65，会越界！

// 正确做法：
char letter = 'C';
int index = letter - 'A';   // 'C' - 'A' = 2
++counts[index];             // 正确！

char s[12] = "Hello World";   // 为什么是 12？因为 11 个字符 + 1 个 '\0'
char s2[] = "Hello World";    // 编译器自动计算大小为 12
char s3[12];                  // 未初始化！内容是垃圾值
char* s4 = "Hello World";    // 指向字符串字面量（不应该修改）
char* s5;                     // 未初始化的指针！危险！

物理长度：数组分配的总大小（比如 128）
逻辑长度：实际有效字符数（到 '\0' 之前的字符数）

char s[128] = "Hello World";

// 方法 1：s.size() —— 不行！C 数组没有 .size() 方法
// for (int i = 0; i < s.size(); ++i)  // 编译错误

// 方法 2：strlen() —— 可以，但效率低（每次循环都要重新计算长度）
for (int i = 0; i < strlen(s); ++i)
    cout << s[i] << endl;

// 方法 3：range-based for —— 可以，但会遍历整个物理数组（包括 '\0' 之后的）
// for (auto c : s)  // 会遍历全部 128 个元素

// 方法 4：检查 '\0' —— 正确且高效
for (int i = 0; s[i] != '\0'; ++i)
    cout << s[i] << endl;

// 方法 5：用指针遍历 —— 正确且地道的 C 风格
for (char* p = s; *p != '\0'; ++p)
    cout << *p << endl;

Complex mySink(3.4, 2.2);
cout << "Sink at location: " << mySink << endl;

// 必须定义为非成员函数！
ostream& operator<<(ostream& out, const Complex& c) {
    c.print(out);   // 调用类的 print 方法
    return out;      // 返回 ostream 引用，支持链式调用
}

class Complex {
    float re, im;
public:
    Complex(float r = 0, float i = 0) : re(r), im(i) {}
    friend ostream& operator<<(ostream& out, const Complex& c);  // 授予访问 re/im 的权限
};

ostream& operator<<(ostream& out, const Complex& c) {
    return out << "(" << c.re << "+" << c.im << "i)";  // 直接访问私有成员
}

cout << "value: " << mySink << endl;
// 等价于：
((cout << "value: ") << mySink) << endl;

ostream& operator<<(ostream& out, const Complex& c)

istream& operator>>(istream& in, Complex& c) {
    c.read(in);     // 注意这里 c 不是 const，因为要修改它
    return in;
}

#include <set>

set<char> S;
for (char c = 'A'; c <= 'Z'; ++c)
    S.insert(c);

for (char c = 'Z'; c >= 'A'; --c)
    S.insert(c);   // 重复插入无效，set 自动去重

for (auto E : S)
    cout << E << endl;   // 输出 A~Z 各一次

if (S.find('A') != S.end())
    cout << "A is in there" << endl;

// C++20: contains() —— 比 find/end 对比更简洁
if (S.contains('A'))
    cout << "A is in there" << endl;

#include <map>
#include <string>

map<string, int> A;
A["Bill"] = 33;
A["George"] = 29;
A["Al"] = 27;

// C++17 之前：通过 .first / .second 访问键值
for (auto E : A)
    cout << E.first << " is " << E.second << " ";
// 输出: Al is 27 Bill is 33 George is 29（按 key 字母序排列）

// C++17：结构化绑定 —— 直接解包为 [key, value]
for (auto [name, age] : A)
    cout << name << " is " << age << " ";
// 输出相同，但可读性更好

// 按键访问
cout << A["Bill"] << endl;      // 33 —— 键不存在时会自动插入默认值！
cout << A.at("Bill") << endl;   // 33 —— 键不存在时抛 std::out_of_range（更安全）

// C++20: contains()
if (A.contains("Bill"))
    cout << "Bill is in the map" << endl;

要修改原变量吗？
├── 是 → void f(Type& x)
└── 否 → 是基本类型（int, double, char, bool）吗？
    ├── 是 → void f(Type x)        // 值传递
    └── 否 → void f(const Type& x) // const 引用